Subject: [Boost-commit] svn:boost r65215 - in sandbox/itl: boost/itl boost/itl/type_traits libs/itl/test
From: afojgo_at_[hidden]
Date: 2010-09-03 06:44:34
Author: jofaber
Date: 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
New Revision: 65215
URL: http://svn.boost.org/trac/boost/changeset/65215
Log:
Refactoring. Unifying interval_sets: Extraction of major functions complete. Stable{msvc-9.0, gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/functions.hpp | 228 ++++++++++++++++++++++++++++++
sandbox/itl/boost/itl/interval_base_set.hpp | 293 ++++++++++-----------------------------
sandbox/itl/boost/itl/split_interval_set.hpp | 6
sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp | 6
sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 6
sandbox/itl/libs/itl/test/vc9_fast_tests.sln | 6
6 files changed, 314 insertions(+), 231 deletions(-)
Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
@@ -11,6 +11,8 @@
#include <boost/mpl/and.hpp>
#include <boost/mpl/or.hpp>
#include <boost/utility/enable_if.hpp>
+#include <boost/itl/type_traits/domain_type_of.hpp>
+#include <boost/itl/type_traits/segment_type_of.hpp>
#include <boost/itl/type_traits/is_interval_container.hpp>
#include <boost/itl/type_traits/is_interval_separator.hpp>
#include <boost/itl/type_traits/is_interval_splitter.hpp>
@@ -550,6 +552,74 @@
//= Intersection
//==============================================================================
//------------------------------------------------------------------------------
+//- Intersection add_intersection
+//------------------------------------------------------------------------------
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+add_intersection(ObjectT& section, const ObjectT& object,
+ const typename ObjectT::domain_type& operand)
+{
+ typedef typename ObjectT::const_iterator const_iterator;
+ const_iterator found = object.find(operand);
+ if(found != object.end())
+ itl::add(section, operand);
+
+ return section;
+}
+
+
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+add_intersection(ObjectT& section, const ObjectT& object,
+ const typename ObjectT::segment_type& segment)
+{
+ typedef typename ObjectT::const_iterator const_iterator;
+ typedef typename ObjectT::iterator iterator;
+ typedef typename ObjectT::interval_type interval_type;
+
+ if(itl::is_empty(segment))
+ return section;
+
+ std::pair<const_iterator, const_iterator> exterior
+ = object.equal_range(segment);
+ if(exterior.first == exterior.second)
+ return section;
+
+ iterator prior_ = section.end();
+ for(const_iterator it_=exterior.first; it_ != exterior.second; it_++)
+ {
+ interval_type common_interval = ObjectT::key_value(it_) & segment;
+ if(!itl::is_empty(common_interval))
+ prior_ = section._insert(prior_, common_interval);
+ }
+ return section;
+}
+
+
+template<class ObjectT, class OperandT>
+typename enable_if<mpl::and_<is_interval_set<ObjectT>,
+ combines_right_to_interval_set<ObjectT, OperandT> >,
+ ObjectT>::type&
+add_intersection(ObjectT& section, const ObjectT& object, const OperandT& operand)
+{
+ typedef typename OperandT::const_iterator const_iterator;
+
+ if(operand.empty())
+ return section;
+
+ const_iterator common_lwb, common_upb;
+ if(!Set::common_range(common_lwb, common_upb, operand, object))
+ return section;
+
+ const_iterator it_ = common_lwb;
+ while(it_ != common_upb)
+ itl::add_intersection(section, object, OperandT::key_value(it_++));
+
+ return section;
+}
+
+
+//------------------------------------------------------------------------------
//- Intersection &=, &
//------------------------------------------------------------------------------
template<class ObjectT, class OperandT>
@@ -585,6 +655,25 @@
//------------------------------------------------------------------------------
//- intersects
//------------------------------------------------------------------------------
+template<class Type, class AssociateT>
+typename enable_if<mpl::and_< is_interval_set<Type>
+ , is_same<AssociateT, domain_type_of<Type> > >,
+ bool>::type
+intersects(const Type& left, const AssociateT& right)
+{
+ return itl::contains(left, right);
+}
+
+template<class Type, class AssociateT>
+typename enable_if<mpl::and_< is_interval_set<Type>
+ , is_same<AssociateT, segment_type_of<Type> > >,
+ bool>::type
+intersects(const Type& left, const AssociateT& right)
+{
+ return left.find(right) != left.end();
+}
+
+//------------------------------------------------------------------------------
#ifdef BOOST_MSVC
#pragma warning(push)
@@ -651,8 +740,9 @@
}
template<class Type, class AssociateT>
-typename enable_if<is_inter_derivative<Type, AssociateT>,
- bool>::type
+typename enable_if<mpl::and_< is_interval_map<Type>
+ , is_inter_derivative<Type, AssociateT> >,
+ bool>::type
intersects(const Type& left, const AssociateT& right)
{
return left.intersects(right);
@@ -686,10 +776,99 @@
//= Symmetric difference
//==============================================================================
//------------------------------------------------------------------------------
-//- Symmetric difference ^=, ^
+//- Symmetric difference flip
//------------------------------------------------------------------------------
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+flip(ObjectT& object, const typename ObjectT::domain_type& operand)
+{
+ if(itl::contains(object, operand))
+ return object -= operand;
+ else
+ return object += operand;
+}
+
+//JODO MEMO: This did not compile, no idea why.
+//template<class ObjectT, class OperandT>
+//typename enable_if<mpl::and_< is_interval_set<ObjectT>
+// , is_same<segment_type_of<ObjectT>, OperandT> >,
+// ObjectT>::type&
+//flip(ObjectT& object, const OperandT& segment)
+
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+flip(ObjectT& object, const typename ObjectT::segment_type& segment)
+{
+ typedef typename ObjectT::const_iterator const_iterator;
+ typedef typename ObjectT::interval_type interval_type;
+ // That which is common shall be subtracted
+ // That which is not shall be added
+ // So x has to be 'complementary added' or flipped
+ interval_type span = segment;
+ std::pair<const_iterator, const_iterator> exterior
+ = object.equal_range(span);
+
+ const_iterator fst_ = exterior.first;
+ const_iterator end_ = exterior.second;
+
+ interval_type covered, left_over;
+ const_iterator it_ = fst_;
+ while(it_ != end_)
+ {
+ covered = *it_++;
+ //[a ... : span
+ // [b ... : covered
+ //[a b) : left_over
+ left_over = right_subtract(span, covered);
+ itl::subtract(object, span & covered); //That which is common shall be subtracted
+ itl::add(object, left_over); //That which is not shall be added
+
+ //... d) : span
+ //... c) : covered
+ // [c d) : span'
+ span = left_subtract(span, covered);
+ }
+
+ //If span is not empty here, it_ is not in the set so it_ shall be added
+ itl::add(object, span);
+ return object;
+}
+
+
+template<class ObjectT, class OperandT>
+typename enable_if<has_same_concept<is_interval_set, ObjectT, OperandT>, ObjectT>::type&
+JODO_flip(ObjectT& object, const OperandT& operand)
+{
+ typedef typename OperandT::const_iterator const_iterator;
+
+ if(operand.empty())
+ return object;
+
+ const_iterator common_lwb, common_upb;
+
+ if(!Set::common_range(common_lwb, common_upb, operand, object))
+ return object += operand;
+
+ const_iterator it_ = operand.begin();
+
+ // All elements of operand left of the common range are added
+ while(it_ != common_lwb)
+ itl::add(object, *it_++);
+ // All elements of operand in the common range are symmertrically subtracted
+ while(it_ != common_upb)
+ itl::flip(object, *it_++);
+ // All elements of operand right of the common range are added
+ while(it_ != operand.end())
+ itl::add(object, *it_++);
+
+ return object;
+}
+
+//------------------------------------------------------------------------------
+//- Symmetric difference ^=, ^
+//------------------------------------------------------------------------------
template<class ObjectT, class OperandT>
typename enable_if<is_intra_combinable<ObjectT, OperandT>,
ObjectT>::type&
@@ -727,6 +906,49 @@
return object ^= operand;
}
+//==============================================================================
+//= Morphisms
+//==============================================================================
+
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+join(ObjectT& object)
+{
+ typedef typename ObjectT::interval_type interval_type;
+ typedef typename ObjectT::iterator iterator;
+
+ iterator it_ = object.begin();
+ if(it_ == object.end())
+ return object;
+
+ iterator next_ = it_; next_++;
+
+ while(next_ != object.end())
+ {
+ if( touches(*it_, *next_) )
+ {
+ iterator fst_mem = it_; // hold the first member
+
+ // Go on while touching members are found
+ it_++; next_++;
+ while( next_ != object.end()
+ && touches(*it_, *next_) )
+ { it_++; next_++; }
+
+ // finally we arrive at the end of a sequence of joinable intervals
+ // and it points to the last member of that sequence
+ const_cast<interval_type&>(*it_) = hull(*it_, *fst_mem);
+ object.erase(fst_mem, it_);
+
+ it_++; next_=it_;
+ if(next_!=object.end())
+ next_++;
+ }
+ else { it_++; next_++; }
+ }
+ return object;
+}
+
}} // namespace itl boost
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
@@ -103,7 +103,7 @@
typename ObjectT::iterator>::type
add(ObjectT& object, typename ObjectT::iterator prior,
const typename ObjectT::segment_type& operand);
-
+//------------------------------------------------------------------------------
template<class ObjectT>
typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
subtract(ObjectT&, const typename ObjectT::element_type&);
@@ -112,6 +112,39 @@
typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
subtract(ObjectT&, const typename ObjectT::segment_type&);
+//------------------------------------------------------------------------------
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+add_intersection(ObjectT&, const ObjectT&, const typename ObjectT::domain_type&);
+
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+add_intersection(ObjectT&, const ObjectT&, const typename ObjectT::segment_type&);
+
+template<class ObjectT, class OperandT>
+typename enable_if<mpl::and_<is_interval_set<ObjectT>,
+ combines_right_to_interval_set<ObjectT, OperandT> >,
+ ObjectT>::type&
+add_intersection(ObjectT&, const ObjectT&, const OperandT&);
+
+//------------------------------------------------------------------------------
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+flip(ObjectT&, const typename ObjectT::domain_type&);
+
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+flip(ObjectT&, const typename ObjectT::segment_type&);
+
+template<class ObjectT, class OperandT>
+typename enable_if<has_same_concept<is_interval_set, ObjectT, OperandT>, ObjectT>::type&
+JODO_flip(ObjectT&, const OperandT&);
+
+//------------------------------------------------------------------------------
+template<class ObjectT>
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
+join(ObjectT&);
+
//JODO Forward 4 gcc-3.4.4 -----------------------------------------------------
@@ -352,6 +385,11 @@
return this->_set.find(interval_type(key));
}
+ const_iterator find(const segment_type& segment)const
+ {
+ return this->_set.find(segment);
+ }
+
//==========================================================================
//= Addition
//==========================================================================
@@ -453,11 +491,16 @@
/** The intersection of \c key in \c *this set is added to \c section.
The function can be used as a find function. */
- void add_intersection(interval_base_set& section, const element_type& key)const
- { add_intersection(section, interval_type(key)); }
+ void add_intersection(SubType& section, const element_type& key)const
+ {
+ itl::add_intersection(section, *that(), key);
+ }
/** The intersection of \c inter_val in \c *this set is added to \c section. */
- void add_intersection(interval_base_set& section, const segment_type& inter_val)const;
+ void add_intersection(SubType& section, const segment_type& inter_val)const
+ {
+ itl::add_intersection(section, *that(), inter_val);
+ }
/** The intersection of set \c sectant with \c *this set is added to \c section. */
@@ -469,20 +512,27 @@
>
void add_intersection
(
- interval_base_set& intersection,
- const IntervalSet<DomainT,Compare,Interval,Alloc>& sectant
- )const;
+ SubType& section,
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
+ )const
+ {
+ itl::add_intersection(section, *that(), operand);
+ }
/** Returns \c true, if element \c key is found in \c *this map.
Complexity: logarithmic. */
bool intersects(const element_type& key)const
- { return _set.find(interval_type(key)) != _set.end(); }
+ {
+ return itl::intersects(*that(), key);
+ }
/** Returns \c true, if \c inter_val intersects with \c *this map.
Complexity: logarithmic. */
bool intersects(const interval_type& inter_val)const
- { return _set.find(inter_val) != _set.end(); }
+ {
+ return itl::intersects(*that(), inter_val);
+ }
//==========================================================================
//= Symmetric difference
@@ -490,15 +540,23 @@
/** If \c *this set contains \c key it is erased, otherwise it is added. */
SubType& flip(const element_type& key)
- { return flip(interval_type(key)); }
+ {
+ return itl::flip(*that(), key);
+ }
/** If \c *this set contains \c inter_val it is erased, otherwise it is added. */
- SubType& flip(const segment_type& inter_val);
+ SubType& flip(const segment_type& inter_val)
+ {
+ return itl::flip(*that(), inter_val);
+ }
/** The intersection of \c *this and \c operand is erased from \c *this.
The complemenary elements are added to \c *this. */
template<class SubType2>
- SubType& flip(const interval_base_set<SubType2,DomainT,Compare,Interval,Alloc>& operand);
+ SubType& flip(const interval_base_set<SubType2,DomainT,Compare,Interval,Alloc>& operand)
+ {
+ return itl::JODO_flip(*that(), operand); //JODO remove this
+ }
//==========================================================================
//= Iterator related
@@ -550,7 +608,10 @@
//==========================================================================
/** Join bordering intervals */
- interval_base_set& join();
+ SubType& join()
+ {
+ return itl::join(*that());
+ }
/** Set interval bounds to the type <tt>bt</tt> for intervals in the set.
Interval bounds of different types are created by opeations on
@@ -606,209 +667,7 @@
ImplSetT _set;
} ;
-
-/*CL
-template
-<
- class SubType, class DomainT,
- ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::size_type
-interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::cardinality()const
-{
- using namespace boost::mpl;
- return if_<
- bool_<is_continuous<DomainT>::value>,
- continuous_interval_container,
- discrete_interval_container
- >
- ::type::cardinality(*this);
-}
-
-template
-<
- class SubType, class DomainT,
- ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-typename
- interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::difference_type
-interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::length()const
-{
- difference_type length = neutron<difference_type>::value();
- const_FOR_IMPL(it_)
- length += itl::length(*it_);
- return length;
-}
-*/
-
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::add_intersection(interval_base_set& section, const segment_type& inter_val)const
-{
- // any intersection with the empty intervall is empty
- if(itl::is_empty(inter_val))
- return;
-
- const_iterator first_ = _set.lower_bound(inter_val);
- const_iterator end_ = _set.upper_bound(inter_val);
-
- iterator prior_ = section.end();
- for(const_iterator it_=first_; it_ != end_; it_++)
- {
- interval_type common_interval = (*it_) & inter_val;
- if(!itl::is_empty(common_interval))
- prior_ = section.gap_insert(prior_, common_interval);
- }
-}
-
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
- template
- <
- template<class DomT, ITL_COMPARE Comp,
- ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
- class IntervalSet
- >
-void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
- ::add_intersection
-(
- interval_base_set& intersection,
- const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
-)const
-{
- typedef IntervalSet<DomainT,Compare,Interval,Alloc> operand_type;
-
- if(operand.empty())
- return;
-
- typename operand_type::const_iterator common_lwb;
- typename operand_type::const_iterator common_upb;
-
- if(!Set::common_range(common_lwb, common_upb, operand, *this))
- return;
-
- typename operand_type::const_iterator it_ = common_lwb;
- while(it_ != common_upb)
- add_intersection(intersection, *it_++);
-}
-
-//==============================================================================
-//= Symmetric difference
-//==============================================================================
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
- ::flip(const segment_type& inter_val)
-{
- // That which is common shall be subtracted
- // That which is not shall be added
- // So x has to be 'complementary added' or flipped
- interval_type span = inter_val;
- typename ImplSetT::const_iterator fst_ = _set.lower_bound(span);
- typename ImplSetT::const_iterator end_ = _set.upper_bound(span);
-
- interval_type covered, left_over;
- typename ImplSetT::const_iterator it_ = fst_;
- while(it_ != end_)
- {
- covered = *it_++;
- //[a ... : span
- // [b ... : covered
- //[a b) : left_over
- left_over = right_subtract(span, covered);
- subtract(span & covered); //That which is common shall be subtracted
- add(left_over); //That which is not shall be added
-
- //... d) : span
- //... c) : covered
- // [c d) : span'
- span = left_subtract(span, covered);
- }
-
- //If span is not empty here, it_ is not in the set so it_ shall be added
- add(span);
- return *that();
-}
-
-
-template
-<
- class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
- template<class SubType2>
-SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
- ::flip(const interval_base_set<SubType2,DomainT,Compare,Interval,Alloc>& operand)
-{
- typedef interval_base_set<SubType2,DomainT,Compare,Interval,Alloc> operand_type;
-
- if(operand.empty())
- return *that();
-
- typename operand_type::const_iterator common_lwb;
- typename operand_type::const_iterator common_upb;
-
- if(!Set::common_range(common_lwb, common_upb, operand, *this))
- return *that() += operand;
-
- typename operand_type::const_iterator it_ = operand.begin();
-
- // All elements of operand left of the common range are added
- while(it_ != common_lwb)
- add(*it_++);
- // All elements of operand in the common range are symmertrically subtracted
- while(it_ != common_upb)
- flip(*it_++);
- // All elements of operand right of the common range are added
- while(it_ != operand.end())
- add(*it_++);
-
- return *that();
-}
-
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
-interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::join()
-{
- iterator it_=_set.begin();
- if(it_==_set.end())
- return *this;
-
- iterator next_=it_; next_++;
-
- while(next_ != _set.end())
- {
- if( touches(*it_, *next_) )
- {
- iterator fst_mem = it_; // hold the first member
-
- // Go on while touching members are found
- it_++; next_++;
- while( next_ != _set.end()
- && touches(*it_, *next_) )
- { it_++; next_++; }
-
- // finally we arrive at the end of a sequence of joinable intervals
- // and it points to the last member of that sequence
- const_cast<interval_type&>(*it_) = hull(*it_, *fst_mem);
- _set.erase(fst_mem, it_);
-
- it_++; next_=it_;
- if(next_!=_set.end())
- next_++;
- }
- else { it_++; next_++; }
- }
- return *this;
-}
-
-
-
+/*JODO uniform_bounds for new interval types
template<class SubType,
class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::uniform_bounds(itl::bound_type bounded)
@@ -817,7 +676,7 @@
// ordering < on interval is invariant wrt. this transformation on bounds
FOR_IMPL(it_) const_cast<interval_type&>(*it_).as(bounded);
}
-
+*/
//==============================================================================
//= Equivalences and Orderings
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
@@ -20,10 +20,10 @@
overlapping intervals are split */
template
<
- typename DomainT,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
+ typename DomainT,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
- ITL_ALLOC Alloc = std::allocator
+ ITL_ALLOC Alloc = std::allocator
>
class split_interval_set:
public interval_base_set<split_interval_set<DomainT,Compare,Interval,Alloc>,
Modified: sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
@@ -10,14 +10,10 @@
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/and.hpp>
+#include <boost/itl/type_traits/no_type.hpp>
namespace boost{ namespace itl
{
- struct no_type{};
-
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF(codomain_type)
Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
@@ -377,9 +377,9 @@
typedef segmentational_fineness<Type> type;
static const int value =
mpl::if_<is_interval_container<Type>,
- known_fineness<Type>,
- unknown_fineness<Type>
- >::type::value;
+ known_fineness<Type>,
+ unknown_fineness<Type>
+ >::type::value;
};
Modified: sandbox/itl/libs/itl/test/vc9_fast_tests.sln
==============================================================================
--- sandbox/itl/libs/itl/test/vc9_fast_tests.sln (original)
+++ sandbox/itl/libs/itl/test/vc9_fast_tests.sln 2010-09-03 06:44:30 EDT (Fri, 03 Sep 2010)
@@ -43,6 +43,8 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_interval_map_mixed", "fastest_interval_map_mixed_\vc9_fastest_interval_map_mixed.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}"
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_combinable", "test_combinable_\vc9_test_combinable.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
@@ -133,6 +135,10 @@
{EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Debug|Win32.Build.0 = Debug|Win32
{EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Release|Win32.ActiveCfg = Release|Win32
{EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE