[Boost-commit] svn:boost r65215 - in sandbox/itl: boost/itl boost/itl/type_traits libs/itl/test

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