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

Subject: [Boost-commit] svn:boost r65217 - in sandbox/itl/boost/itl: . detail functions
From: afojgo_at_[hidden]
Date: 2010-09-03 12:27:12

Author: jofaber
Date: 2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
New Revision: 65217
URL: http://svn.boost.org/trac/boost/changeset/65217

Log:
Refactoring. Unifying interval_maps: Extraction of functions. Removed Tabs. Stable{msvc-9.0, gcc-3.4.4}
Text files modified: 
   sandbox/itl/boost/itl/detail/associated_value.hpp                 |     6                                         
   sandbox/itl/boost/itl/detail/interval_map_algo.hpp                |    59 ++++++++++++++                          
   sandbox/itl/boost/itl/detail/interval_set_algo.hpp                |   132 ++++++++++++++++++++------------        
   sandbox/itl/boost/itl/functions.hpp                               |    84 ++++++++++----------                    
   sandbox/itl/boost/itl/functions/associative_element_container.hpp |     2                                         
   sandbox/itl/boost/itl/interval_base_map.hpp                       |    22 ++--                                    
   sandbox/itl/boost/itl/interval_base_set.hpp                       |   156 +++++++++++++++++++-------------------  
   sandbox/itl/boost/itl/interval_map.hpp                            |   162 +++++---------------------------------- 
   sandbox/itl/boost/itl/interval_set.hpp                            |    10 +-                                      
   sandbox/itl/boost/itl/map.hpp                                     |     2                                         
   sandbox/itl/boost/itl/map_functions.hpp                           |     4                                         
   sandbox/itl/boost/itl/separate_interval_set.hpp                   |     6                                         
   sandbox/itl/boost/itl/set.hpp                                     |    22 ++--                                    
   sandbox/itl/boost/itl/split_interval_set.hpp                      |     6                                         
   14 files changed, 322 insertions(+), 351 deletions(-)

Modified: sandbox/itl/boost/itl/detail/associated_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/associated_value.hpp	(original)
+++ sandbox/itl/boost/itl/detail/associated_value.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -20,8 +20,8 @@
 typename enable_if< mpl::and_< is_domain_compare_equal<Type,CoType>
                              , mpl::and_<is_map<Type>, is_map<CoType> > >, 
                     bool>::type
-co_equal(typename Type::const_iterator left_, typename CoType::const_iterator right_,
-		 const Type&, const CoType&)
+co_equal(typename Type::const_iterator left_, typename CoType::const_iterator right_, 
+		 const Type* = 0, const CoType* = 0)
 {
         return Type::co_value(left_) == CoType::co_value(right_);
 }
@@ -31,7 +31,7 @@
                              , mpl::not_<mpl::and_<is_map<Type>, is_map<CoType> > > >,
                   bool>::type
 co_equal(typename Type::const_iterator, typename CoType::const_iterator,
-		 const Type&, const CoType&)
+		 const Type* = 0, const CoType* = 0)
 {
         return true;
 }

Modified: sandbox/itl/boost/itl/detail/interval_map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_map_algo.hpp	(original)
+++ sandbox/itl/boost/itl/detail/interval_map_algo.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -166,7 +166,64 @@
 
 
 } // namespace Interval_Map
-    
+
+
+namespace detail
+{
+
+
+template <class Type, class Combiner>
+inline typename Type::iterator
+gap_insert(               Type&                object, 
+                 typename Type::iterator       prior_, 
+           const typename Type::interval_type& inter_val, 
+           const typename Type::codomain_type& co_val)
+{
+    typedef typename Type::value_type value_type;
+    // inter_val is not conained in this map. Insertion will be successful
+    BOOST_ASSERT(object.find(inter_val) == object.end());
+    BOOST_ASSERT(!(absorbs_neutrons<Type>::value && co_val==Combiner::neutron()));
+
+    return object._insert(prior_, value_type(inter_val, version<Combiner>()(co_val)));
+}
+
+
+template<class Type, class Combiner>
+void add_segment(               Type&                object,
+                 const typename Type::interval_type& inter_val, 
+                 const typename Type::codomain_type& co_val, 
+                       typename Type::iterator&      it_       )
+{
+    typedef typename Type::interval_type interval_type;
+    typedef typename Type::iterator      iterator;
+
+    interval_type lead_gap = right_subtract(inter_val, it_->first);
+    if(!itl::is_empty(lead_gap))
+    {
+        // [lead_gap--- . . .
+        //          [-- it_ ...
+        iterator prior_ = prior(it_); 
+        iterator inserted_ = gap_insert<Type,Combiner>(object, prior_, lead_gap, co_val);
+        if(prior_ != object.end() && joinable(object, prior_, inserted_))
+            join_on_right(object, prior_, inserted_);
+    }
+
+    // . . . --------- . . . addend interval
+    //      [-- it_ --)      has a common part with the first overval
+    Combiner()(it_->second, co_val);
+	if(absorbs_neutrons<Type>::value && it_->second == Combiner::neutron())
+        object.erase(it_++);
+    else
+    {
+        detail::join_left(object, it_);
+        ++it_;
+    }
+}
+
+
+
+} // namespace detail
+
 }} // namespace itl boost
 
 #endif 

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-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -17,6 +17,7 @@
 #include <boost/itl/interval.hpp>
 #include <boost/itl/detail/element_comparer.hpp>
 #include <boost/itl/detail/interval_subset_comparer.hpp>
+#include <boost/itl/detail/associated_value.hpp>
 
 namespace boost{namespace itl
 {
@@ -289,76 +290,101 @@
 {
 
 template<class Type>
-typename Type::iterator 
+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)) 
+        && co_equal(some, next, &_Type, &_Type); 
+}
+
+template<class Type>
+inline void join_nodes(Type& object, typename Type::iterator& left_, 
+					                 typename Type::iterator& right_)
+{
+    typedef typename Type::interval_type interval_type;
+    interval_type right_interval = Type::key_value(right_);
+    object.erase(right_);
+    const_cast<interval_type&>(Type::key_value(left_)) 
+        = hull(Type::key_value(left_), right_interval);
+}
+
+template<class Type>
+inline typename Type::iterator 
     join_on_left(Type& object, typename Type::iterator& left_, 
                                typename Type::iterator& right_)
 {
-    typedef typename Type::value_type    value_type;
     typedef typename Type::interval_type interval_type;
     // both left and right are in the set and they are neighbours
     BOOST_ASSERT(exclusive_less(Type::key_value(left_), Type::key_value(right_)));
-    BOOST_ASSERT(touches(Type::key_value(left_), Type::key_value(right_)));
-
-    interval_type right_itv = Type::key_value(right_);
-    object.erase(right_);
-    const_cast<value_type&>(Type::key_value(left_)) 
-        = hull(Type::key_value(left_), right_itv);
+    BOOST_ASSERT(joinable(object, left_, right_));
 
+	join_nodes(object, left_, right_);
     return left_;
 }
 
 template<class Type>
-typename Type::iterator
-    join_neighbours(Type& object, typename Type::iterator it_)
+inline typename Type::iterator 
+    join_on_right(Type& object, typename Type::iterator& left_, 
+                                typename Type::iterator& right_)
 {
-    using namespace detail;
-    typedef typename Type::iterator iterator;
+    typedef typename Type::interval_type interval_type;
+    // both left and right are in the map and they are neighbours
+    BOOST_ASSERT(exclusive_less(Type::key_value(left_), Type::key_value(right_)));
+    BOOST_ASSERT(joinable(object, left_, right_));
+
+	join_nodes(object, left_, right_);
+    right_ = left_;
+    return right_;
+}
+
+
+
+
+
+template<class Type>
+typename Type::iterator join_left(Type& object, typename Type::iterator& it_)
+{
+	typedef typename Type::iterator iterator;
 
     if(it_ == object.begin())
-    {
-        iterator it_nxt=it_; it_nxt++;
-        if(it_nxt!=object.end() && touches(Type::key_value(it_), 
-                                           Type::key_value(it_nxt))) 
-            return join_on_left(object, it_, it_nxt);
-    }
-    else
-    {
-        // there is a predecessor
-        iterator pred_ = it_; pred_-- ;
+        return it_;
 
-        if(touches(Type::key_value(pred_), Type::key_value(it_))) 
-        {
-            iterator it_extended = join_on_left(object, pred_, it_);
+    // there is a predecessor
+    iterator pred_ = it_;
+	if(joinable(object, --pred_, it_)) 
+		return join_on_right(object, pred_, it_); 
+
+    return it_;
+}
 
-            iterator succ_=it_extended; succ_++;
-            if(succ_!=object.end())
-            {
-                // it's a non border element that might have two touching neighbours
-                if(touches(Type::key_value(it_extended), Type::key_value(succ_))) 
-                    return join_on_left(object, it_extended, succ_);
-                else
-                    return it_extended;
-            }
-            else
-                return it_extended;
-        }
-        else
-        {
-            iterator succ_=it_; succ_++;
-            if(succ_!=object.end())
-            {
-                // it's a non border element that might have a right touching neighbour
-                if(touches(Type::key_value(it_), Type::key_value(succ_))) 
-                    return join_on_left(object, it_, succ_);
-            }
-        }
-    }
+
+template<class Type>
+typename Type::iterator join_right(Type& object, typename Type::iterator& it_)
+{
+	typedef typename Type::iterator iterator;
+
+    if(it_ == object.end())
+        return it_;
+
+    // there is a successor
+    iterator succ_ = it_;
+
+	if(++succ_ != object.end() && joinable(object, it_, succ_)) 
+        return join_on_left(object, it_, succ_);
 
     return it_;
 }
 
 
 template<class Type>
+typename Type::iterator join_neighbours(Type& object, typename Type::iterator& it_)
+{
+           join_left (object, it_); 
+	return join_right(object, it_);
+}
+
+
+template<class Type>
 typename Type::iterator 
     join_under(Type& object, const typename Type::value_type& addend)
 {
@@ -403,7 +429,10 @@
     if(insertion.second)
         return join_neighbours(object, insertion.first);
     else
-        return join_neighbours(object, join_under(object, addend));
+	{
+		iterator joined_ = join_under(object, addend);
+        return join_neighbours(object, joined_);
+	}
 }
 
 template<class Type>
@@ -423,7 +452,10 @@
     if(*insertion == addend)
         return join_neighbours(object, insertion);
     else
-        return join_neighbours(object, join_under(object, addend));
+	{
+		iterator joined_ = join_under(object, addend);
+        return join_neighbours(object, joined_);
+	}
 }
 
 

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp	(original)
+++ sandbox/itl/boost/itl/functions.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -185,7 +185,7 @@
                             , is_interval_joiner<ObjectT> >, ObjectT>::type&
 add(ObjectT& object, const typename ObjectT::element_type& operand)
 {
-	detail::joining_add(object, typename ObjectT::interval_type(operand));
+    detail::joining_add(object, typename ObjectT::interval_type(operand));
     return object; //JODO: May be it is better to return the iterator
 }
 
@@ -194,7 +194,7 @@
                             , is_interval_joiner<ObjectT> >, ObjectT>::type&
 add(ObjectT& object, const typename ObjectT::segment_type& operand)
 {
-	detail::joining_add(object, operand);
+    detail::joining_add(object, operand);
     return object; //JODO: May be it is better to return the iterator
 }
 
@@ -214,7 +214,7 @@
                             , is_interval_separator<ObjectT> >, ObjectT>::type&
 add(ObjectT& object, const typename ObjectT::element_type& operand)
 {
-	detail::separating_add(object, typename ObjectT::interval_type(operand));
+    detail::separating_add(object, typename ObjectT::interval_type(operand));
     return object;
 }
 
@@ -243,7 +243,7 @@
                             , is_interval_splitter<ObjectT> >, ObjectT>::type&
 add(ObjectT& object, const typename ObjectT::element_type& operand)
 {
-	detail::splitting_add(object, typename ObjectT::interval_type(operand));
+    detail::splitting_add(object, typename ObjectT::interval_type(operand));
     return object;
 }
 
@@ -278,7 +278,7 @@
 {
     typename ObjectT::iterator prior_ = object.end();
     ITL_const_FORALL(typename OperandT, elem_, operand) 
-		prior_ = object.add(prior_, *elem_); //JODO
+        prior_ = object.add(prior_, *elem_); //JODO
 
     return object; 
 }
@@ -308,8 +308,8 @@
 typename enable_if<is_intra_derivative<ObjectT, OperandT>, ObjectT>::type&
 operator += (ObjectT& object, const OperandT& operand)
 { 
-	//JODO return itl::add(object, operand); 
-	return object.add(operand); 
+    //JODO return itl::add(object, operand); 
+    return object.add(operand); 
 }
 
 //CL
@@ -472,7 +472,7 @@
 operator -=(ObjectT& object, const OperandT& operand)
 {
     ITL_const_FORALL(typename OperandT, elem_, operand) 
-		object.subtract(*elem_); //JODO 
+        object.subtract(*elem_); //JODO 
 
     return object; 
 }
@@ -481,8 +481,8 @@
 typename enable_if<is_intra_derivative<ObjectT, OperandT>, ObjectT>::type&
 operator -= (ObjectT& object, const OperandT& operand)
 { 
-	//JODO return itl::subtract(object, operand); 
-	return object.subtract(operand); 
+    //JODO return itl::subtract(object, operand); 
+    return object.subtract(operand); 
 }
 
 template<class ObjectT, class OperandT>
@@ -557,25 +557,25 @@
 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)
+                          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);
+    typedef typename ObjectT::const_iterator const_iterator;
+    const_iterator found = object.find(operand);
+    if(found != object.end())
+        itl::add(section, operand);
 
-	return section;
+    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)
+                          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;
+    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;
@@ -588,11 +588,11 @@
     iterator prior_ = section.end();
     for(const_iterator it_=exterior.first; it_ != exterior.second; it_++) 
     {
-		interval_type common_interval = ObjectT::key_value(it_) & segment;
+        interval_type common_interval = ObjectT::key_value(it_) & segment;
         if(!itl::is_empty(common_interval))
             prior_ = section._insert(prior_, common_interval);
     }
-	return section;
+    return section;
 }
 
 
@@ -602,7 +602,7 @@
                    ObjectT>::type&
 add_intersection(ObjectT& section, const ObjectT& object, const OperandT& operand)
 {
-	typedef typename OperandT::const_iterator const_iterator;
+    typedef typename OperandT::const_iterator const_iterator;
 
     if(operand.empty())
         return section;
@@ -613,9 +613,9 @@
 
     const_iterator it_ = common_lwb;
     while(it_ != common_upb)
-		itl::add_intersection(section, object, OperandT::key_value(it_++));
+        itl::add_intersection(section, object, OperandT::key_value(it_++));
 
-	return section;
+    return section;
 }
 
 
@@ -661,7 +661,7 @@
                    bool>::type
 intersects(const Type& left, const AssociateT& right)
 {
-	return itl::contains(left, right); 
+    return itl::contains(left, right); 
 }
 
 template<class Type, class AssociateT>
@@ -783,10 +783,10 @@
 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;
+    if(itl::contains(object, operand))
+        return object -= operand;
+    else
+        return object += operand;
 }
 
 //JODO MEMO: This did not compile, no idea why.
@@ -800,14 +800,14 @@
 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;
+    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);
+    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;
@@ -821,8 +821,8 @@
         //     [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
+        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
@@ -831,7 +831,7 @@
     }
 
     //If span is not empty here, it_ is not in the set so it_ shall be added
-	itl::add(object, span);
+    itl::add(object, span);
     return object;
 }
 
@@ -840,7 +840,7 @@
 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;
+    typedef typename OperandT::const_iterator const_iterator;
 
     if(operand.empty())
         return object;
@@ -854,7 +854,7 @@
 
     // All elements of operand left of the common range are added
     while(it_ != common_lwb)
-		itl::add(object, *it_++);
+        itl::add(object, *it_++);
     // All elements of operand in the common range are symmertrically subtracted
     while(it_ != common_upb)
         itl::flip(object, *it_++);
@@ -914,8 +914,8 @@
 typename enable_if<is_interval_set<ObjectT>, ObjectT>::type&
 join(ObjectT& object)
 {
-	typedef typename ObjectT::interval_type interval_type;
-	typedef typename ObjectT::iterator      iterator;
+    typedef typename ObjectT::interval_type interval_type;
+    typedef typename ObjectT::iterator      iterator;
 
     iterator it_ = object.begin();
     if(it_ == object.end()) 

Modified: sandbox/itl/boost/itl/functions/associative_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions/associative_element_container.hpp	(original)
+++ sandbox/itl/boost/itl/functions/associative_element_container.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -60,7 +60,7 @@
         super_ = super.find(SubT::key_value(sub_));
         if(super_ == super.end()) 
             return false;
-        else if(!co_equal(sub_, super_, sub, super))
+        else if(!co_equal(sub_, super_, &sub, &super))
             return false;
 
         ++sub_;

Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp	(original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -283,15 +283,15 @@
 
     /** Number of elements in the map (cardinality). */
     size_type cardinality()const
-	{
-		return itl::cardinality(*that());
-	}
+    {
+        return itl::cardinality(*that());
+    }
 
     /** An interval map's size is it's cardinality */
     size_type size()const
-	{
-		return itl::cardinality(*that());
-	}
+    {
+        return itl::cardinality(*that());
+    }
 
     /** The length of the interval container which is the sum of 
         interval lengths */
@@ -337,6 +337,8 @@
         return _map.find(interval_type(key)); 
     }
 
+    const_iterator find(const key_type& key)const{ return _map.find(key); }
+
     /** Total select function. */
     codomain_type operator()(const domain_type& key)const
     {
@@ -414,6 +416,9 @@
     //= Insertion
     //==========================================================================
 
+    std::pair<iterator,bool> _insert(const value_type& value_pair){ return _map.insert(value_pair); }
+    iterator _insert(iterator prior, const value_type& value_pair){ return _map.insert(prior, value_pair); }
+
     /** Insertion of a \c key_value_pair into the map. */
     SubType& insert(const element_type& key_value_pair) 
     { 
@@ -828,10 +833,7 @@
         BOOST_ASSERT(this->_map.find(inter_val) == this->_map.end());
         BOOST_ASSERT(!(Traits::absorbs_neutrons && co_val==Combiner::neutron()));
 
-        if(mpl::and_<has_inverse<codomain_type>, is_negative<Combiner> >::value)
-            return this->_map.insert(prior_, value_type(inter_val, version<Combiner>()(co_val)));
-        else
-            return this->_map.insert(prior_, value_type(inter_val, co_val));
+        return this->_map.insert(prior_, value_type(inter_val, version<Combiner>()(co_val)));
     }
 
 protected:

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 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -287,28 +287,28 @@
     //==========================================================================
 
     /** sets the container empty */
-	void clear() { itl::clear(*that()); }
+    void clear() { itl::clear(*that()); }
     /** is the container empty? */
-	bool empty()const { return itl::is_empty(*that()); }
+    bool empty()const { return itl::is_empty(*that()); }
 
     /** Does the container contain the element \c key ? */
     bool contains(const element_type& key)const
-	{ 
-		return itl::contains(*that(), key); 
-	}
+    { 
+        return itl::contains(*that(), key); 
+    }
 
     /** Does the container contain the interval \c sub_interval ? */
     bool contains(const segment_type& sub_interval)const
     { 
-		return itl::contains(*that(), sub_interval);
+        return itl::contains(*that(), sub_interval);
     }
 
 
     /** Does the container contain the subcontainer \c sub ? */
     bool contains(const interval_base_set& sub)const 
-	{ 
-		return itl::within(sub, *that()); 
-	}
+    { 
+        return itl::within(sub, *that()); 
+    }
 
     /** Does <tt>*this</tt> container contain <tt>sub</tt>? */
     template
@@ -319,8 +319,8 @@
     >
     bool contains(const IntervalSet<DomainT,Compare,Interval,Alloc>& sub)const 
     { 
-		return itl::within(sub,*that()); 
-	}
+        return itl::within(sub,*that()); 
+    }
 
     /** Is <tt>*this</tt> container contained in <tt>super</tt>? */
     template
@@ -341,39 +341,39 @@
     /** Number of elements in the set (cardinality). 
         Infinite for continuous domain datatyps    */
     size_type cardinality()const
-	{
-		return itl::cardinality(*that());
-	}
+    {
+        return itl::cardinality(*that());
+    }
 
     /** An interval set's size is it's cardinality */
     size_type size()const
-	{
-		return itl::cardinality(*that());
-	}
+    {
+        return itl::cardinality(*that());
+    }
 
     /** The length of the interval container which is the sum of interval lengths */
     difference_type length()const
-	{
-		return itl::length(*that());
-	}
+    {
+        return itl::length(*that());
+    }
 
     /** Number of intervals which is also the size of the iteration over the object */
     std::size_t interval_count()const 
-	{ 
-		return itl::interval_count(*that()); 
-	}
+    { 
+        return itl::interval_count(*that()); 
+    }
 
     /** Size of the iteration over this container */
     std::size_t iterative_size()const 
-	{ 
-		return _set.size(); 
-	}
+    { 
+        return _set.size(); 
+    }
 
     //==========================================================================
     //= Range
     //==========================================================================
 
-	//JODO remove lower, upper, first, last from the interface of all interval containers and docs
+    //JODO remove lower, upper, first, last from the interface of all interval containers and docs
 
     //==========================================================================
     //= Selection
@@ -397,22 +397,22 @@
     /** Add a single element \c key to the set */
     SubType& add(const element_type& key) 
     {
-		return itl::add(*that(), key);
-	}
+        return itl::add(*that(), key);
+    }
 
     /** Add an interval of elements \c inter_val to the set */
     SubType& add(const segment_type& inter_val) 
     {
-		return itl::add(*that(), inter_val);
-	}
+        return itl::add(*that(), inter_val);
+    }
 
     /** Add an interval of elements \c inter_val to the set. Iterator 
         \c prior_ is a hint to the position \c inter_val can be 
         inserted after. */
     iterator add(iterator prior_, const segment_type& inter_val) 
     { 
-		return itl::add(*that(), prior_, inter_val);
-	}
+        return itl::add(*that(), prior_, inter_val);
+    }
 
     //==========================================================================
     //= Subtraction
@@ -421,68 +421,68 @@
     /** Subtract a single element \c key from the set */
     SubType& subtract(const element_type& key) 
     { 
-		return itl::subtract(*that(), key);
-	}
+        return itl::subtract(*that(), key);
+    }
 
     /** Subtract an interval of elements \c inter_val from the set */
     SubType& subtract(const segment_type& inter_val) 
     { 
-		return itl::subtract(*that(), inter_val);
-	}
+        return itl::subtract(*that(), inter_val);
+    }
 
     //==========================================================================
     //= Insertion, erasure
     //==========================================================================
 
-	std::pair<iterator,bool> _insert(const value_type& value){ return this->_set.insert(value); }
-	iterator _insert(iterator prior, const value_type& value){ return this->_set.insert(prior, value); }
+    std::pair<iterator,bool> _insert(const value_type& value){ return this->_set.insert(value); }
+    iterator _insert(iterator prior, const value_type& value){ return this->_set.insert(prior, value); }
 
 
     /** Insert an element \c key into the set */
     SubType& insert(const element_type& key) 
-	{ 
-		return itl::add(*that(), key); 
-	}
+    { 
+        return itl::add(*that(), key); 
+    }
 
     /** Insert an interval of elements \c inter_val to the set */
     SubType& insert(const segment_type& inter_val) 
-	{ 
-		return itl::add(*that(), inter_val); 
-	}
+    { 
+        return itl::add(*that(), inter_val); 
+    }
 
     /** Insert an interval of elements \c inter_val to the set. Iterator 
         \c prior_ is a hint to the position \c inter_val can be 
         inserted after. */
     iterator insert(iterator prior_, const segment_type& inter_val) 
     { 
-		return itl::add(*that(), prior_, inter_val); 
-	}
+        return itl::add(*that(), prior_, inter_val); 
+    }
 
 
 
     /** Erase an element \c key from the set */
     SubType& erase(const element_type& key) 
     { 
-		return itl::subtract(*that(), key); 
-	}
+        return itl::subtract(*that(), key); 
+    }
 
     /** Erase an interval of elements \c inter_val from the set */
     SubType& erase(const segment_type& inter_val) 
     { 
-		return itl::subtract(*that(), inter_val); 
-	}
+        return itl::subtract(*that(), inter_val); 
+    }
 
     /** Erase the interval that iterator \c position points to. */
     void erase(iterator position)
-	{ 
-		_set.erase(position); 
-	}
+    { 
+        _set.erase(position); 
+    }
 
     /** Erase all intervals in the range <tt>[first,past)</tt> of iterators. */
     void erase(iterator first, iterator past)
-	{ 
-		_set.erase(first, past); 
-	}
+    { 
+        _set.erase(first, past); 
+    }
 
 
     //==========================================================================
@@ -493,14 +493,14 @@
         The function can be used as a find function. */
     void add_intersection(SubType& section, const element_type& key)const
     {
-		itl::add_intersection(section, *that(), key); 
-	}
+        itl::add_intersection(section, *that(), key); 
+    }
 
     /** The intersection of \c inter_val in \c *this set is added to \c section. */
     void add_intersection(SubType& section, const segment_type& inter_val)const
     {
-		itl::add_intersection(section, *that(), inter_val); 
-	}
+        itl::add_intersection(section, *that(), inter_val); 
+    }
 
 
     /** The intersection of set \c sectant with \c *this set is added to \c section. */
@@ -515,24 +515,24 @@
         SubType& section,
         const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
     )const
-	{
-		itl::add_intersection(section, *that(), operand);
-	}
+    {
+        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 itl::intersects(*that(), key); 
-	}
+        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 itl::intersects(*that(), inter_val); 
-	}
+        return itl::intersects(*that(), inter_val); 
+    }
 
     //==========================================================================
     //= Symmetric difference
@@ -541,22 +541,22 @@
     /** If \c *this set contains \c key it is erased, otherwise it is added. */
     SubType& flip(const element_type& key)
     {
-		return itl::flip(*that(), 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)
     {
-		return itl::flip(*that(), 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)
-	{
-		return itl::JODO_flip(*that(), operand); //JODO remove this
-	}
+    {
+        return itl::JODO_flip(*that(), operand); //JODO remove this
+    }
 
     //==========================================================================
     //= Iterator related
@@ -609,9 +609,9 @@
     
     /** Join bordering intervals */
     SubType& join()
-	{
-		return itl::join(*that());
-	}
+    {
+        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

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp	(original)
+++ sandbox/itl/boost/itl/interval_map.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -146,13 +146,6 @@
             && !(Traits::absorbs_neutrons && value.second == codomain_combine::neutron()); 
     }
 
-    iterator join_left(iterator& it_);
-    iterator join_right(iterator& it_);
-    iterator join_neighbours(iterator& it_){ join_left(it_); return join_right(it_); };
-    bool joinable(const iterator& some, const iterator& next)const;
-    iterator join_on_left(iterator& some, const iterator& next);
-    iterator join_on_right(const iterator& some, iterator& next);
-
     template<class Combiner>
     void add_main(interval_type& inter_val, const CodomainT& co_val, 
                   iterator& it_, const iterator& last_);
@@ -163,9 +156,6 @@
     void add_front(const interval_type& inter_val, iterator& first_);
 
     template<class Combiner>
-    void add_segment(const interval_type& inter_val, const CodomainT& co_val, iterator& it_);
-
-    template<class Combiner>
     void subtract_main(const CodomainT& co_val, iterator& it_, iterator& end_  );
 
     void subtract_front(const interval_type& inter_val, const CodomainT& co_val, iterator& it_);
@@ -179,86 +169,6 @@
 
 } ;
 
-template <typename DomainT, typename CodomainT, class Traits,
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
-inline bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-    ::joinable(const iterator& some, const iterator& next)const
-{
-    // assert: next != end && some++ == next
-    return touches(some->first, next->first) 
-        && some->second == next->second; 
-}
-
-
-template <typename DomainT, typename CodomainT, class Traits,
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
-inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator 
-    interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-    ::join_on_left(iterator& left_, const iterator& right_)
-{
-    // both left and right are in the map and they are neighbours
-    BOOST_ASSERT(joinable(left_, right_));
-
-    interval_type right_interval = right_->first;
-    this->_map.erase(right_);
-    const_cast<interval_type&>(left_->first) = hull(left_->first, right_interval);
-    
-    return left_;
-}
-
-template <typename DomainT, typename CodomainT, class Traits,
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
-inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator 
-    interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-    ::join_on_right(const iterator& left_, iterator& right_)
-{
-    // both left and right are in the map and they are neighbours
-    BOOST_ASSERT(joinable(left_, right_));
-
-    interval_type right_interval = right_->first;
-    this->_map.erase(right_);
-    const_cast<interval_type&>(left_->first) = hull(left_->first, right_interval);
-    right_ = left_;
-
-    return right_;
-}
-
-
-template <typename DomainT, typename CodomainT, class Traits,
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
-inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
-    interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-    ::join_left(iterator& it_)
-{
-    if(it_ == this->_map.begin())
-        return it_;
-
-    // there is a predecessor
-    iterator pred_ = it_;
-    if(joinable(--pred_, it_)) 
-        return join_on_right(pred_, it_); 
-
-    return it_;
-}
-
-template <typename DomainT, typename CodomainT, class Traits,
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
-inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
-    interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-    ::join_right(iterator& it_)
-{
-    if(it_ == this->_map.end())
-        return it_;
-
-    // there is a successor
-    iterator succ_ = it_;
-
-    if(++succ_ != this->_map.end() && joinable(it_, succ_)) 
-        return join_on_left(it_, succ_);
-
-    return it_;
-}
-
 
 //-----------------------------------------------------------------------------
 // add<Combinator>(pair(interval,value)):
@@ -280,7 +190,7 @@
         = this->template _map_insert<Combiner>(inter_val, co_val);
 
     if(insertion.second)
-        join_neighbours(insertion.first);
+        detail::join_neighbours(*this, insertion.first);
     else
     {
         // Detect the first and the end iterator of the collision sequence
@@ -316,7 +226,7 @@
         = this->template _map_add<Combiner>(prior_, inter_val, co_val);
 
     if(insertion.second)
-        return join_neighbours(insertion.first);
+        return detail::join_neighbours(*this, insertion.first);
     else
     {
         // Detect the first and the end iterator of the collision sequence
@@ -370,7 +280,7 @@
     while(it_!=last_)
     {
         cur_interval = it_->first ;
-        add_segment<Combiner>(x_rest, co_val, it_);
+        detail::add_segment<type,Combiner>(*this, x_rest, co_val, it_);
         // shrink interval
         x_rest = left_subtract(x_rest, cur_interval);
     }
@@ -380,36 +290,6 @@
 template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
     template<class Combiner>
 inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-    ::add_segment(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
-{
-    interval_type lead_gap = right_subtract(inter_val, it_->first);
-    if(!itl::is_empty(lead_gap))
-    {
-        // [lead_gap--- . . .
-        //          [-- it_ ...
-        iterator prior_ = prior(it_); 
-        iterator inserted_ = this->template gap_insert<Combiner>(prior_, lead_gap, co_val);
-        if(prior_ != this->_map.end() && joinable(prior_, inserted_))
-            join_on_right(prior_, inserted_);
-    }
-
-    // . . . --------- . . . addend interval
-    //      [-- it_ --)      has a common part with the first overval
-    Combiner()(it_->second, co_val);
-    if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
-        this->_map.erase(it_++);
-    else
-    {
-        join_left(it_);
-        ++it_;
-    }
-}
-
-
-
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
-    template<class Combiner>
-inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
     iterator prior_ = this->prior(it_);
@@ -420,8 +300,8 @@
     {   //         [lead_gap--- . . .
         // [prior)          [-- it_ ...
         iterator inserted_ = this->template gap_insert<Combiner>(prior_, lead_gap, co_val);
-        if(prior_ != this->_map.end() && joinable(prior_, inserted_))
-            join_on_left(prior_, inserted_);
+        if(prior_ != this->_map.end() && detail::joinable(*this, prior_, inserted_))
+            detail::join_on_left(*this, prior_, inserted_);
     }
 
     interval_type end_gap = left_subtract(inter_val, cur_itv);
@@ -435,13 +315,13 @@
         {
             this->_map.erase(it_);
             it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
-            join_right(it_);
+            detail::join_right(*this, it_);
         }
         else
         {
-            join_left(it_);
+            detail::join_left(*this, it_);
             iterator inserted_ = this->template gap_insert<Combiner>(it_, end_gap, co_val);
-            it_ = join_neighbours(inserted_);
+            it_ = detail::join_neighbours(*this, inserted_);
         }
     }
     else
@@ -461,7 +341,7 @@
                 it_ = prior_;
             }
             else
-                join_neighbours(it_);
+                detail::join_neighbours(*this, it_);
         }
         else
         {
@@ -473,7 +353,7 @@
             // the Combiner functor. It only reestablished that state after splitting the
             // 'it_' interval value pair. Using _map_insert<Combiner> does not work here.
             iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
-            join_right(insertion_);
+            detail::join_right(*this, insertion_);
 
             Combiner()(it_->second, co_val);
 
@@ -483,7 +363,7 @@
                 it_ = insertion_;
             }
             else
-                join_neighbours(it_);
+                detail::join_neighbours(*this, it_);
         }
     }
 }
@@ -550,7 +430,7 @@
             this->_map.erase(it_++); 
         else
         {
-            join_left(it_);
+            detail::join_left(*this, it_);
             ++it_;
         }
     }
@@ -571,7 +451,7 @@
         if(Traits::absorbs_neutrons && cur_val==Combiner::neutron())
             this->_map.erase(it_);
         else
-            join_neighbours(it_);
+            detail::join_neighbours(*this, it_);
     }
     else
     {
@@ -581,12 +461,12 @@
         if(Traits::absorbs_neutrons && it_->second==Combiner::neutron())
         {
             this->_map.erase(it_);
-            join_right(next_);
+            detail::join_right(*this, next_);
         }
         else
         {
-            join_left(it_);
-            join_neighbours(next_);
+            detail::join_left(*this, it_);
+            detail::join_neighbours(*this, next_);
         }
     }
 }
@@ -611,7 +491,7 @@
     std::pair<iterator,bool> insertion = this->_map.insert(addend);
 
     if(insertion.second)
-        join_neighbours(insertion.first);
+        detail::join_neighbours(*this, insertion.first);
     else
     {
         // Detect the first and the end iterator of the collision sequence
@@ -641,7 +521,7 @@
         = this->template _map_insert<codomain_combine>(prior_, inter_val, co_val);
 
     if(insertion.second)
-        return join_neighbours(insertion.first);
+        return detail::join_neighbours(*this, insertion.first);
     {
         // Detect the first and the end iterator of the collision sequence
         std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
@@ -674,9 +554,9 @@
         if(!itl::is_empty(left_gap))
         {
             inserted_ = this->_map.insert(prior_, value_type(left_gap, co_val));
-            join_left(inserted_);
+            detail::join_left(*this, inserted_);
             // after filling that gap there may be another joining opportunity
-            join_left(it_);
+            detail::join_left(*this, it_);
         }
 
         // shrink interval
@@ -690,7 +570,7 @@
     if(!itl::is_empty(end_gap))
     {
         inserted_ = this->_map.insert(prior_, value_type(end_gap, co_val));
-        it_ = join_neighbours(inserted_);
+        it_ = detail::join_neighbours(*this, inserted_);
     }
     else
         it_ = prior_;

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-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -138,8 +138,8 @@
             prior_ = this->add(prior_, *it_);
     }
 
-	//std::pair<iterator,bool> _insert(const value_type& value){ return this->_set.insert(value); }
-	//iterator _insert(iterator prior, const value_type& value){ return this->_set.insert(prior, value); }
+    //std::pair<iterator,bool> _insert(const value_type& value){ return this->_set.insert(value); }
+    //iterator _insert(iterator prior, const value_type& value){ return this->_set.insert(prior, value); }
 
 private:
     friend class 
@@ -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)
 {
-	detail::joining_add(*this, addend);
+    detail::joining_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 detail::joining_add(*this, prior_, addend);
+    return detail::joining_add(*this, prior_, addend);
 }
 
 
@@ -179,7 +179,7 @@
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 void interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& minuend)
 {
-	detail::subtract(*this, minuend);
+    detail::subtract(*this, minuend);
 }
 
 

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp	(original)
+++ sandbox/itl/boost/itl/map.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -324,7 +324,7 @@
 
     map& flip(const element_type& operand)
     { 
-		return itl::flip(*this, operand); 
+        return itl::flip(*this, operand); 
     }
 
     //==========================================================================

Modified: sandbox/itl/boost/itl/map_functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/map_functions.hpp	(original)
+++ sandbox/itl/boost/itl/map_functions.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -39,7 +39,7 @@
 typename enable_if<is_element_map<MapT>, bool>::type
 contains(const MapT& super, const typename MapT::element_type& value_pair)
 {
-	return itl::within(value_pair, super);
+    return itl::within(value_pair, super);
 }
 
 
@@ -505,7 +505,7 @@
 inline typename enable_if<is_element_map<MapT>, MapT>::type&
 absorb_neutrons(MapT& object)
 {
-	BOOST_STATIC_CONSTANT(bool, absorbs = MapT::Traits::absorbs_neutrons);
+    BOOST_STATIC_CONSTANT(bool, absorbs = MapT::Traits::absorbs_neutrons);
     return map_absorb_neutrons<MapT,absorbs>::apply(object);
 }
 

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-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -148,21 +148,21 @@
 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)
 {
-	detail::separating_add(*this, addend);
+    detail::separating_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 detail::separating_add(*this, prior_, addend);
+    return detail::separating_add(*this, prior_, addend);
 }
 
 
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 inline void separate_interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& minuend)
 {
-	detail::subtract(*this, minuend);
+    detail::subtract(*this, minuend);
 }
 
 //-----------------------------------------------------------------------------

Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp	(original)
+++ sandbox/itl/boost/itl/set.hpp	2010-09-03 12:27:04 EDT (Fri, 03 Sep 2010)
@@ -51,7 +51,7 @@
 public:
     typedef typename itl::set<DomainT, Compare, Alloc> type;
     typedef typename ITL_IMPL_SPACE::set<DomainT, ITL_COMPARE_DOMAIN(Compare,DomainT), Alloc<DomainT> > base_type;
-	typedef type key_object_type;
+    typedef type key_object_type;
 
 public:
     typedef DomainT     domain_type;
@@ -150,11 +150,11 @@
 
     /// Checks if the element \c value is in the set
     bool contains(const element_type& value)const 
-	{ return itl::contains(*this, value); }
+    { return itl::contains(*this, value); }
 
     /** Does <tt>*this</tt> contain <tt>sub</tt>? */
     bool contains(const set& sub)const 
-	{ return itl::contains(*this, sub); }
+    { return itl::contains(*this, sub); }
 
     /** Is <tt>*this</tt> contained in <tt>super</tt>? */
     bool contained_in(const set& super)const 
@@ -162,7 +162,7 @@
 
     /** <tt>*this</tt> and <tt>x2</tt> are disjoint, if their intersection is empty */
     bool disjoint(const set& x2)const 
-	{ return itl::disjoint(*this, x2); }
+    { return itl::disjoint(*this, x2); }
 
     //==========================================================================
     //= Size
@@ -179,21 +179,21 @@
     //==========================================================================
     /** Add an \c element to the set. */
     set& add(const element_type& element) 
-	{ return itl::insert(*this, element); } 
+    { return itl::insert(*this, element); } 
 
     /** Add an element \c element after \c prior to the set. */
     iterator add(iterator prior, const element_type& element) 
-	{ return itl::insert(*this, prior, element); } 
+    { return itl::insert(*this, prior, element); } 
 
     /** Subtract an \c element from the set. */
     set& subtract(const element_type& element)
-	{ return itl::subtract(*this, element); } 
+    { return itl::subtract(*this, element); } 
 
     //==========================================================================
     //= Insertion, erasure
     //==========================================================================
 
-	//JODO
+    //JODO
 
     //==========================================================================
     //= Intersection, symmetric difference
@@ -201,12 +201,12 @@
 
     /** Add \c element to \c section, if \c element is in \c *this set */
     void add_intersection(set& section, const element_type& element)const
-	{ itl::add_intersection(section, *this, element); }
+    { itl::add_intersection(section, *this, element); }
 
     /** The intersection of set \c sectant with \c *this set is added 
         to \c section. */
     void add_intersection(set& section, const set& sectant)const
-	{ itl::add_intersection(section, *this, sectant); }
+    { itl::add_intersection(section, *this, sectant); }
 
     /** Returns true, if there is an intersection of \c element and \c *this set.
         Functions \c intersects and \c contains are identical on arguments
@@ -215,7 +215,7 @@
 
     /** If \c *this set contains \c element it is erased, otherwise it is added. */
     set& flip(const element_type& element)
-	{ return itl::flip(*this, element); }
+    { return itl::flip(*this, element); }
 
 
     //==========================================================================

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 12:27:04 EDT (Fri, 03 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)
 {
-	detail::splitting_add(*this, addend);
+    detail::splitting_add(*this, addend);
 }
 
 
@@ -157,13 +157,13 @@
 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 detail::splitting_add(*this, prior_, addend);
+    return detail::splitting_add(*this, prior_, addend);
 }
 
 template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE)  Interval, ITL_ALLOC Alloc>
 inline void split_interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& minuend)
 {
-	detail::subtract(*this, minuend);
+    detail::subtract(*this, minuend);
 }
 
 //-----------------------------------------------------------------------------