[Boost-commit] svn:boost r65328 - in sandbox/itl/boost/itl: . detail

Subject: [Boost-commit] svn:boost r65328 - in sandbox/itl/boost/itl: . detail
From: afojgo_at_[hidden]
Date: 2010-09-07 06:01:14

Author: jofaber
Date: 2010-09-07 06:01:12 EDT (Tue, 07 Sep 2010)
New Revision: 65328
URL: http://svn.boost.org/trac/boost/changeset/65328

Log:
Refactoring: Unified joining, separating and splitting addition on interval sets by partial implementations of a static class on_style<T, combining_style>. Stable{msvc-9.0, gcc-3.4.4}
Text files modified: 
   sandbox/itl/boost/itl/detail/interval_set_algo.hpp |   252 ++++++++++++++++++++------------------- 
   sandbox/itl/boost/itl/functions.hpp                |    76 -----------                             
   sandbox/itl/boost/itl/interval_base_set.hpp        |    47 ------                                  
   sandbox/itl/boost/itl/interval_set.hpp             |     4                                         
   sandbox/itl/boost/itl/separate_interval_set.hpp    |     4                                         
   sandbox/itl/boost/itl/split_interval_set.hpp       |     4                                         
   6 files changed, 145 insertions(+), 242 deletions(-)

Modified: sandbox/itl/boost/itl/detail/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_set_algo.hpp	(original)
+++ sandbox/itl/boost/itl/detail/interval_set_algo.hpp	2010-09-07 06:01:12 EDT (Tue, 07 Sep 2010)
@@ -15,6 +15,7 @@
 #include <boost/itl/type_traits/is_total.hpp>
 #include <boost/itl/type_traits/is_combinable.hpp>
 #include <boost/itl/interval.hpp>
+#include <boost/itl/interval_combining_style.hpp>
 #include <boost/itl/detail/element_comparer.hpp>
 #include <boost/itl/detail/interval_subset_comparer.hpp>
 #include <boost/itl/detail/associated_value.hpp>
@@ -293,13 +294,13 @@
 inline bool joinable(const Type& _Type, typename Type::iterator& some, typename Type::iterator& next)
 {
     // assert: next != end && some++ == next
-	return touches(Type::key_value(some), Type::key_value(next)) 
+    return touches(Type::key_value(some), Type::key_value(next)) 
         && co_equal(some, next, &_Type, &_Type); 
 }
 
 template<class Type>
 inline void join_nodes(Type& object, typename Type::iterator& left_, 
-					                 typename Type::iterator& right_)
+                                     typename Type::iterator& right_)
 {
     typedef typename Type::interval_type interval_type;
     interval_type right_interval = Type::key_value(right_);
@@ -318,7 +319,7 @@
     BOOST_ASSERT(exclusive_less(Type::key_value(left_), Type::key_value(right_)));
     BOOST_ASSERT(joinable(object, left_, right_));
 
-	join_nodes(object, left_, right_);
+    join_nodes(object, left_, right_);
     return left_;
 }
 
@@ -332,7 +333,7 @@
     BOOST_ASSERT(exclusive_less(Type::key_value(left_), Type::key_value(right_)));
     BOOST_ASSERT(joinable(object, left_, right_));
 
-	join_nodes(object, left_, right_);
+    join_nodes(object, left_, right_);
     right_ = left_;
     return right_;
 }
@@ -344,15 +345,15 @@
 template<class Type>
 typename Type::iterator join_left(Type& object, typename Type::iterator& it_)
 {
-	typedef typename Type::iterator iterator;
+    typedef typename Type::iterator iterator;
 
     if(it_ == object.begin())
         return it_;
 
     // there is a predecessor
     iterator pred_ = it_;
-	if(joinable(object, --pred_, it_)) 
-		return join_on_right(object, pred_, it_); 
+    if(joinable(object, --pred_, it_)) 
+        return join_on_right(object, pred_, it_); 
 
     return it_;
 }
@@ -361,7 +362,7 @@
 template<class Type>
 typename Type::iterator join_right(Type& object, typename Type::iterator& it_)
 {
-	typedef typename Type::iterator iterator;
+    typedef typename Type::iterator iterator;
 
     if(it_ == object.end())
         return it_;
@@ -369,7 +370,7 @@
     // there is a successor
     iterator succ_ = it_;
 
-	if(++succ_ != object.end() && joinable(object, it_, succ_)) 
+    if(++succ_ != object.end() && joinable(object, it_, succ_)) 
         return join_on_left(object, it_, succ_);
 
     return it_;
@@ -380,12 +381,12 @@
 typename Type::iterator join_neighbours(Type& object, typename Type::iterator& it_)
 {
            join_left (object, it_); 
-	return join_right(object, it_);
+    return join_right(object, it_);
 }
 
 
 template<class Type>
-typename Type::iterator 
+inline typename Type::iterator 
     join_under(Type& object, const typename Type::value_type& addend)
 {
     //ASSERT: There is at least one interval in object that overlaps with addend
@@ -410,130 +411,154 @@
     return first_;
 }
 
-} // namespace segmental
-
-namespace Interval_Set
-{
-using namespace segmental;
-
-//==============================================================================
-//= Addition joining
-//==============================================================================
 template<class Type>
-typename Type::iterator 
-    joining_add(Type& object, const typename Type::value_type& addend)
+inline typename Type::iterator 
+    join_under(Type& object, const typename Type::value_type& addend,
+                                   typename Type::iterator last_)
 {
+    //ASSERT: There is at least one interval in object that overlaps with addend
     typedef typename Type::iterator      iterator;
     typedef typename Type::interval_type interval_type;
     typedef typename Type::value_type    value_type;
 
-    if(itl::is_empty(addend)) 
-        return object.end();
+    iterator first_ = object.lower_bound(addend);
+    //BOOST_ASSERT(next(last_) == this->_set.upper_bound(inter_val));
+    iterator second_= next(first_), end_ = next(last_);
 
-    std::pair<iterator,bool> insertion = object._insert(addend);
+    interval_type left_resid  = right_subtract(Type::key_value(first_), addend);
+    interval_type right_resid =  left_subtract(Type::key_value(last_) , addend);
 
-    if(insertion.second)
-		return join_neighbours(object, insertion.first);
-    else
-	{
-		iterator joined_ = join_under(object, addend);
-        return join_neighbours(object, joined_);
-	}
+    object.erase(second_, end_);
+
+    const_cast<value_type&>(Type::key_value(first_)) 
+        = hull(hull(left_resid, addend), right_resid);
+    return first_;
 }
 
+} // namespace segmental
+
+namespace Interval_Set
+{
+using namespace segmental;
+
+template<class Type, int combining_style>
+struct on_style;
+
 template<class Type>
-typename Type::iterator 
-    joining_add(Type& object, typename Type::iterator    prior_, 
-                        const typename Type::value_type& addend)
+struct on_style<Type, interval_combine::joining>
 {
-    typedef typename Type::iterator      iterator;
+    typedef          on_style            type;
     typedef typename Type::interval_type interval_type;
-    typedef typename Type::value_type    value_type;
+    typedef typename Type::iterator      iterator;
 
-    if(itl::is_empty(addend)) 
-        return prior_;
+    inline static iterator handle_inserted(Type& object, iterator inserted_)
+    { return join_neighbours(object, inserted_); }
 
-    iterator insertion = object._insert(prior_, addend);
+    inline static iterator add_over
+        (Type& object, const interval_type& addend, iterator last_)
+    {
+		iterator joined_ = join_under(object, addend, last_);
+        return join_neighbours(object, joined_);
+    }
 
-    if(*insertion == addend)
-        return join_neighbours(object, insertion);
-    else
-	{
+    inline static iterator add_over
+        (Type& object, const interval_type& addend)
+    {
                 iterator joined_ = join_under(object, addend);
         return join_neighbours(object, joined_);
-	}
-}
-
+    }
+};
 
-//==============================================================================
-//= Addition separating
-//==============================================================================
 template<class Type>
-typename Type::iterator 
-    separating_add(Type& object, const typename Type::value_type& addend)
+struct on_style<Type, interval_combine::separating>
 {
-    typedef typename Type::iterator      iterator;
+    typedef          on_style            type;
     typedef typename Type::interval_type interval_type;
-    typedef typename Type::value_type    value_type;
+    typedef typename Type::iterator      iterator;
 
-    if(itl::is_empty(addend)) 
-        return object.end();
+    inline static iterator handle_inserted(Type&, iterator inserted_)
+    { return inserted_; }
 
-    std::pair<iterator,bool> insertion = object._insert(addend);
+    inline static iterator add_over
+        (Type& object, const interval_type& addend, iterator last_)
+    {
+        return join_under(object, addend, last_);
+    }
 
-    if(insertion.second)
-        return insertion.first;
-    else
+    inline static iterator add_over
+        (Type& object, const interval_type& addend)
+    {
         return join_under(object, addend);
-}
+    }
+};
 
 template<class Type>
-typename Type::iterator 
-    separating_add(Type& object, typename Type::iterator    prior_, 
-                           const typename Type::value_type& addend)
+struct on_style<Type, interval_combine::splitting>
 {
-    typedef typename Type::iterator      iterator;
+    typedef          on_style            type;
     typedef typename Type::interval_type interval_type;
-    typedef typename Type::value_type    value_type;
+    typedef typename Type::iterator      iterator;
 
-    if(itl::is_empty(addend)) 
-        return prior_;
+    inline static iterator handle_inserted(Type&, iterator inserted_)
+    { return inserted_; }
 
-    iterator insertion = object._insert(prior_, addend);
+    inline static iterator add_over
+        (Type& object, const interval_type& addend, iterator last_)
+    {
+        iterator first_ = object.lower_bound(addend);
+        //BOOST_ASSERT(next(last_) == this->_set.upper_bound(inter_val));
 
-    if(*insertion == addend)
-        return insertion;
-    else
-        return join_under(object, addend);
-}
+        iterator it_ = first_;
+        interval_type rest_interval = addend;
 
+        add_front(object, rest_interval, it_);
+        add_main (object, rest_interval, it_, last_);
+        add_rear (object, rest_interval, it_);
+        return it_;
+    }
+
+    inline static iterator add_over
+        (Type& object, const interval_type& addend)
+    {
+        std::pair<iterator,iterator> overlap = object.equal_range(addend);
+        iterator first_ = overlap.first,
+                 end_   = overlap.second,
+                 last_  = end_; --last_;
+
+        iterator it_ = first_;
+        interval_type rest_interval = addend;
+
+        add_front(object, rest_interval, it_);
+        add_main (object, rest_interval, it_, last_);
+        add_rear (object, rest_interval, it_);
+
+        return it_;
+    }
+};
 
-//==============================================================================
-//= Addition splitting
-//==============================================================================
 
 template<class Type>
 void add_front(Type& object, const typename Type::interval_type& inter_val, 
                                    typename Type::iterator&      first_)
 {
-	typedef typename Type::interval_type interval_type;
-	typedef typename Type::iterator      iterator;
+    typedef typename Type::interval_type interval_type;
+    typedef typename Type::iterator      iterator;
     // If the collision sequence has a left residual 'left_resid' it will
     // be split, to provide a standardized start of algorithms:
     // The addend interval 'inter_val' covers the beginning of the collision sequence.
 
     // only for the first there can be a left_resid: a part of *first_ left of inter_val
-	interval_type left_resid = right_subtract(Type::key_value(first_), inter_val);
+    interval_type left_resid = right_subtract(Type::key_value(first_), inter_val);
 
     if(!itl::is_empty(left_resid))
     {   //            [------------ . . .
         // [left_resid---first_ --- . . .
         iterator prior_ = object.prior(first_);
         const_cast<interval_type&>(Type::key_value(first_)) 
-			= left_subtract(Type::key_value(first_), left_resid);
+            = left_subtract(Type::key_value(first_), left_resid);
         //NOTE: Only splitting
         //CL iterator insertion_ = 
-		object._insert(prior_, Type::make_value(left_resid, Type::co_value(first_)));
+        object._insert(prior_, Type::make_value(left_resid, Type::co_value(first_)));
     }
 
     //POST:
@@ -546,7 +571,7 @@
 void add_segment(Type& object, const typename Type::interval_type& inter_val, 
                                      typename Type::iterator&      it_      )
 {
-	typedef typename Type::interval_type interval_type;
+    typedef typename Type::interval_type interval_type;
     interval_type lead_gap = right_subtract(inter_val, *it_);
     if(!itl::is_empty(lead_gap))
         //           [lead_gap--- . . .
@@ -564,7 +589,7 @@
                             typename Type::iterator&      it_,
                       const typename Type::iterator&      last_)
 {
-	typedef typename Type::interval_type interval_type;
+    typedef typename Type::interval_type interval_type;
     interval_type cur_interval;
     while(it_ != last_)
     {
@@ -580,8 +605,8 @@
 void add_rear(Type& object, const typename Type::interval_type& inter_val, 
                                   typename Type::iterator&      it_      )
 {
-	typedef typename Type::interval_type interval_type;
-	typedef typename Type::iterator      iterator;
+    typedef typename Type::interval_type interval_type;
+    typedef typename Type::iterator      iterator;
 
     iterator prior_ = object.prior(it_);
     interval_type cur_itv = *it_;
@@ -613,12 +638,16 @@
 }
 
 
+//==============================================================================
+//= Addition
+//==============================================================================
 template<class Type>
 typename Type::iterator 
-    splitting_add(Type& object, const typename Type::value_type& addend)
+    add(Type& object, const typename Type::value_type& addend)
 {
-	typedef typename Type::interval_type interval_type;
-	typedef typename Type::iterator      iterator;
+    typedef typename Type::interval_type interval_type;
+    typedef typename Type::iterator      iterator;
+    typedef typename on_style<Type, Type::fineness>::type on_style_;
 
     if(itl::is_empty(addend)) 
         return object.end();
@@ -626,30 +655,20 @@
     std::pair<iterator,bool> insertion = object._insert(addend);
 
     if(insertion.second)
-        return insertion.first;
-    {
-        iterator first_ = object.lower_bound(addend),
-                 last_  = insertion.first;
-        //BOOST_ASSERT(next(last_) == this->_set.upper_bound(inter_val));
-
-        iterator it_ = first_;
-        interval_type rest_interval = addend;
-
-        add_front(object, rest_interval, it_);
-        add_main (object, rest_interval, it_, last_);
-        add_rear (object, rest_interval, it_);
-        return it_;
-    }
+        return on_style_::handle_inserted(object, insertion.first);
+    else
+        return on_style_::add_over(object, addend, insertion.first);
 }
 
 
 template<class Type>
 typename Type::iterator 
-    splitting_add(Type& object, typename Type::iterator    prior_, 
-	                      const typename Type::value_type& addend)
+    add(Type& object, typename Type::iterator    prior_, 
+                const typename Type::value_type& addend)
 {
-	typedef typename Type::interval_type interval_type;
-	typedef typename Type::iterator      iterator;
+    typedef typename Type::interval_type interval_type;
+    typedef typename Type::iterator      iterator;
+    typedef typename on_style<Type, Type::fineness>::type on_style_;
 
     if(itl::is_empty(addend)) 
         return prior_;
@@ -657,22 +676,9 @@
     iterator insertion = object._insert(prior_, addend);
 
     if(*insertion == addend)
-        return insertion;
-    {
-        std::pair<iterator,iterator> overlap = object.equal_range(addend);
-        iterator first_ = overlap.first,
-                 end_   = overlap.second,
-                 last_  = end_; --last_;
-
-        iterator it_ = first_;
-        interval_type rest_interval = addend;
-
-        add_front(object, rest_interval, it_);
-        add_main (object, rest_interval, it_, last_);
-        add_rear (object, rest_interval, it_);
-
-        return it_;
-    }
+        return on_style_::handle_inserted(object, insertion);
+    else
+        return on_style_::add_over(object, addend);
 }
 
 

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp	(original)
+++ sandbox/itl/boost/itl/functions.hpp	2010-09-07 06:01:12 EDT (Tue, 07 Sep 2010)
@@ -178,92 +178,28 @@
 //==============================================================================
 //= Addition
 //==============================================================================
-
-//- joining_add ----------------------------------------------------------------
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_joiner<ObjectT> >, ObjectT>::type&
-add(ObjectT& object, const typename ObjectT::element_type& operand)
-{
-    Interval_Set::joining_add(object, typename ObjectT::interval_type(operand));
-    return object; //JODO: May be it is better to return the iterator
-}
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_joiner<ObjectT> >, ObjectT>::type&
-add(ObjectT& object, const typename ObjectT::segment_type& operand)
-{
-    Interval_Set::joining_add(object, operand);
-    return object; //JODO: May be it is better to return the iterator
-}
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_joiner<ObjectT> >, 
-                   typename ObjectT::iterator>::type
-add(ObjectT& object, typename ObjectT::iterator      prior, 
-               const typename ObjectT::segment_type& operand)
-{
-    return Interval_Set::joining_add(object, prior, operand);
-}
-
-//- separating_add -------------------------------------------------------------
 template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_separator<ObjectT> >, ObjectT>::type&
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
 add(ObjectT& object, const typename ObjectT::element_type& operand)
 {
-    Interval_Set::separating_add(object, typename ObjectT::interval_type(operand));
+    Interval_Set::add(object, typename ObjectT::interval_type(operand));
     return object;
 }
 
 template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_separator<ObjectT> >, ObjectT>::type&
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
 add(ObjectT& object, const typename ObjectT::segment_type& operand)
 {
-    Interval_Set::separating_add(object, operand);
-    return object; //JODO: May be it is better to return the iterator
-}
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_separator<ObjectT> >,
-                   typename ObjectT::iterator>::type
-add(ObjectT& object, typename ObjectT::iterator      prior, 
-               const typename ObjectT::segment_type& operand)
-{
-    return Interval_Set::separating_add(object, prior, operand);
-}
-
-//- splitting_add -------------------------------------------------------------
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_splitter<ObjectT> >, ObjectT>::type&
-add(ObjectT& object, const typename ObjectT::element_type& operand)
-{
-    Interval_Set::splitting_add(object, typename ObjectT::interval_type(operand));
+    Interval_Set::add(object, operand);
     return object;
 }
 
 template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_splitter<ObjectT> >, ObjectT>::type&
-add(ObjectT& object, const typename ObjectT::segment_type& operand)
-{
-    Interval_Set::splitting_add(object, operand);
-    return object; //JODO: May be it is better to return the iterator
-}
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_splitter<ObjectT> >,
-                   typename ObjectT::iterator>::type
+typename enable_if<is_interval_set<ObjectT>, typename ObjectT::iterator>::type
 add(ObjectT& object, typename ObjectT::iterator      prior, 
                const typename ObjectT::segment_type& operand)
 {
-    return Interval_Set::splitting_add(object, prior, operand);
+    return Interval_Set::add(object, prior, operand);
 }
 //------------------------------------------------------------------------------
 

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-07 06:01:12 EDT (Tue, 07 Sep 2010)
@@ -50,60 +50,21 @@
 typename enable_if<is_interval_set<ObjectT>, bool>::type
 contains(const ObjectT& super, const typename ObjectT::element_type&);
 
-//- joining_add -------------------------------------------------------------
+//- add ------------------------------------------------------------------------
 template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_joiner<ObjectT> >, ObjectT>::type&
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
 add(ObjectT&, const typename ObjectT::element_type&);
 
 template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_joiner<ObjectT> >, ObjectT>::type&
+typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
 add(ObjectT&, const typename ObjectT::segment_type&);
 
 template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_joiner<ObjectT> >, 
-                   typename ObjectT::iterator>::type
+typename enable_if<is_interval_set<ObjectT>, typename ObjectT::iterator>::type
 add(ObjectT&, typename ObjectT::iterator, 
         const typename ObjectT::segment_type&);
 
-//- separating_add -------------------------------------------------------------
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_separator<ObjectT> >, ObjectT>::type&
-add(ObjectT&, const typename ObjectT::element_type&);
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_separator<ObjectT> >, ObjectT>::type&
-add(ObjectT& object, const typename ObjectT::segment_type& operand);
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_separator<ObjectT> >,
-                   typename ObjectT::iterator>::type
-add(ObjectT& object, typename ObjectT::iterator      prior, 
-               const typename ObjectT::segment_type& operand);
 
-//- splitting_add -------------------------------------------------------------
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_splitter<ObjectT> >, ObjectT>::type&
-add(ObjectT&, const typename ObjectT::element_type&);
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_splitter<ObjectT> >, ObjectT>::type&
-add(ObjectT& object, const typename ObjectT::segment_type& operand);
-
-template<class ObjectT>
-typename enable_if<mpl::and_< is_interval_set<ObjectT>
-                            , is_interval_splitter<ObjectT> >,
-                   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&);

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp	(original)
+++ sandbox/itl/boost/itl/interval_set.hpp	2010-09-07 06:01:12 EDT (Tue, 07 Sep 2010)
@@ -163,7 +163,7 @@
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 void interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& addend)
 {
-    Interval_Set::joining_add(*this, addend);
+    Interval_Set::add(*this, addend);
 }
 
 
@@ -171,7 +171,7 @@
 typename interval_set<DomainT,Compare,Interval,Alloc>::iterator 
     interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
-    return Interval_Set::joining_add(*this, prior_, addend);
+    return Interval_Set::add(*this, prior_, addend);
 }
 
 

Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp	(original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp	2010-09-07 06:01:12 EDT (Tue, 07 Sep 2010)
@@ -148,14 +148,14 @@
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 inline void separate_interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& addend)
 {
-    Interval_Set::separating_add(*this, addend);
+    Interval_Set::add(*this, addend);
 }
 
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 typename separate_interval_set<DomainT,Compare,Interval,Alloc>::iterator 
     separate_interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
-    return Interval_Set::separating_add(*this, prior_, addend);
+    return Interval_Set::add(*this, prior_, addend);
 }
 
 

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-07 06:01:12 EDT (Tue, 07 Sep 2010)
@@ -149,7 +149,7 @@
 template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 inline void split_interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& addend)
 {
-    Interval_Set::splitting_add(*this, addend);
+    Interval_Set::add(*this, addend);
 }
 
 
@@ -157,7 +157,7 @@
 inline typename split_interval_set<DomainT,Compare,Interval,Alloc>::iterator
     split_interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
-    return Interval_Set::splitting_add(*this, prior_, addend);
+    return Interval_Set::add(*this, prior_, addend);
 }
 
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>