Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r56081 - in sandbox/itl: boost/itl boost/itl/detail boost/itl_xt boost/validate/driver boost/validate/laws libs/itl/test libs/validate/example/labat_polygon_
From: afojgo_at_[hidden]
Date: 2009-09-07 03:54:43


Author: jofaber
Date: 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
New Revision: 56081
URL: http://svn.boost.org/trac/boost/changeset/56081

Log:
Refactoring: Replaced readability macros form notate.hpp by the raw code and
prefixed iteration macros FOR.. by ITL_ to prevent clashes with user macro definitions.
Text files modified:
   sandbox/itl/boost/itl/detail/notate.hpp | 31 +-------
   sandbox/itl/boost/itl/functions.hpp | 6
   sandbox/itl/boost/itl/interval_base_map.hpp | 114 ++++++++++++++++----------------
   sandbox/itl/boost/itl/interval_base_set.hpp | 2
   sandbox/itl/boost/itl/interval_map.hpp | 138 ++++++++++++++++++++--------------------
   sandbox/itl/boost/itl/interval_morphism.hpp | 8 +-
   sandbox/itl/boost/itl/interval_set.hpp | 10 +-
   sandbox/itl/boost/itl/interval_set_algo.hpp | 4
   sandbox/itl/boost/itl/map.hpp | 66 +++++++++---------
   sandbox/itl/boost/itl/map_algo.hpp | 26 +++---
   sandbox/itl/boost/itl/separate_interval_set.hpp | 8 +-
   sandbox/itl/boost/itl/set.hpp | 4
   sandbox/itl/boost/itl/set_algo.hpp | 4
   sandbox/itl/boost/itl/split_interval_map.hpp | 116 ++++++++++++++++----------------
   sandbox/itl/boost/itl/split_interval_set.hpp | 4
   sandbox/itl/boost/itl_xt/episode_product.hpp | 44 ++++++------
   sandbox/itl/boost/itl_xt/mapgentor.hpp | 8 +-
   sandbox/itl/boost/itl_xt/prefix_set.cpp | 6
   sandbox/itl/boost/itl_xt/seqgentor.hpp | 8 +-
   sandbox/itl/boost/itl_xt/setgentor.hpp | 8 +-
   sandbox/itl/boost/itl_xt/string_set.hpp | 2
   sandbox/itl/boost/itl_xt/string_sheet.cpp | 2
   sandbox/itl/boost/itl_xt/tuple_computer.hpp | 34 ++++----
   sandbox/itl/boost/itl_xt/var_permutation.hpp | 2
   sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp | 2
   sandbox/itl/boost/itl_xt/var_tuple_order.hpp | 4
   sandbox/itl/boost/validate/driver/itl_driver.hpp | 20 ++--
   sandbox/itl/boost/validate/laws/law_violations.hpp | 2
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 2
   sandbox/itl/libs/itl/test/test_itl_map.hpp | 2
   sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp | 12 +-
   31 files changed, 339 insertions(+), 360 deletions(-)

Modified: sandbox/itl/boost/itl/detail/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/notate.hpp (original)
+++ sandbox/itl/boost/itl/detail/notate.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -15,36 +15,15 @@
 
 
 // Iterations over stl or stl-compatible containers:
-#define FORALL(type,iter,obj) for(type::iterator iter=(obj).begin(); (iter)!=(obj).end(); (iter)++)
-#define const_FORALL(type,iter,obj) for(type::const_iterator iter=(obj).begin(); !((iter)==(obj).end()); (iter)++)
+#define ITL_FORALL(type,iter,obj) for(type::iterator iter=(obj).begin(); (iter)!=(obj).end(); (iter)++)
+#define ITL_const_FORALL(type,iter,obj) for(type::const_iterator iter=(obj).begin(); !((iter)==(obj).end()); (iter)++)
 
-#define FORALL_THIS(iter) for(iterator iter=begin(); (iter)!=end(); (iter)++)
-#define const_FORALL_THIS(iter) for(const_iterator iter=this->begin(); (iter)!=this->end(); (iter)++)
+#define ITL_FORALL_THIS(iter) for(iterator iter=begin(); (iter)!=end(); (iter)++)
+#define ITL_const_FORALL_THIS(iter) for(const_iterator iter=this->begin(); (iter)!=this->end(); (iter)++)
 
 // Plain old array iteration (assuming memberfunction VecT::size()!)
-#define FORALL_VEC(idx, vec) for(int idx=0; idx<vec.size(); idx++)
+#define ITL_FORALL_VEC(idx, vec) for(int idx=0; idx<vec.size(); idx++)
 
-// Parallel iteration
-#define const_FORALL_THIS_2(it, it2, cnt2)\
- for(const_iterator it=begin(), it2=(cnt2).begin(); (it)!=end() && (it2)!=cnt2.end(); (it)++, (it2)++)
-#define const_FORALL_THIS_PARALLEL(it, it2, cnt2)\
- for(const_iterator it=begin(), it2=(cnt2).begin(); (it)!=end() && (it2)!=cnt2.end(); (it)++, (it2)++)
-
-// Variants that requires already declared iterators
-#define FOR_ALL(iter,obj) for((iter)=(obj).begin(); (iter)!=(obj).end(); (iter)++)
-#define FOR_ALL_THIS(iter) for((iter)=this->begin(); (iter)!=this->end(); (iter)++)
-
-#define FOR_ALL2(iter1,obj1, iter2,obj2)\
- for((iter1)=(obj1).begin(), (iter2)=(obj2).begin(); (iter1)!=(obj1).end(); ++(iter1),++(iter2))
-
-// for readability and ease of memory: pair selectors for different contexts
-#define ITERATOR first // x.insert(y).second
-#define WAS_SUCCESSFUL second
-
-#define KEY_VALUE first // for map valuePairs
-#define CONT_VALUE second
-
-// universal and maths
 namespace boost{namespace itl
 {
     const int UNDEFINED_INDEX = -1;

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -86,7 +86,7 @@
 operator += (ObjectT& object, const OperandT& operand)
 {
     typename ObjectT::iterator prior_ = object.end();
- const_FORALL(typename OperandT, elem_, operand)
+ ITL_const_FORALL(typename OperandT, elem_, operand)
         prior_ = object.add(prior_, *elem_);
 
     return object;
@@ -256,7 +256,7 @@
                           ObjectT>::type&
 operator -=(ObjectT& object, const OperandT& operand)
 {
- const_FORALL(typename OperandT, elem_, operand)
+ ITL_const_FORALL(typename OperandT, elem_, operand)
         object.subtract(*elem_);
 
     return object;
@@ -303,7 +303,7 @@
 insert(ObjectT& object, const OperandT& operand)
 {
     typename ObjectT::iterator prior_ = object.end();
- const_FORALL(typename OperandT, elem_, operand)
+ ITL_const_FORALL(typename OperandT, elem_, operand)
         object.insert(*elem_);
 
     return object;

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 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -214,7 +214,7 @@
         const_iterator last_overlap = prior(exterior.second);
 
         return
- hull(exterior.first->KEY_VALUE, last_overlap->KEY_VALUE).contains(sub_interval)
+ hull(exterior.first->first, last_overlap->first).contains(sub_interval)
         && Interval_Set::is_dense(*this, exterior.first, last_overlap);
     }
 
@@ -282,21 +282,21 @@
 
     /** Lower bound of the first interval */
     DomainT lower()const
- { return empty()? interval_type().lower() : (*(_map.begin())).KEY_VALUE.lower(); }
+ { return empty()? interval_type().lower() : (*(_map.begin())).first.lower(); }
 
     /** Upper bound of the last interval */
     DomainT upper()const
- { return empty()? interval_type().upper() : (*(_map.rbegin())).KEY_VALUE.upper(); }
+ { return empty()? interval_type().upper() : (*(_map.rbegin())).first.upper(); }
 
     /** Smallest element of the map (wrt. the partial ordering on DomainT).
         first() does not exist for continuous datatypes and open interval
         bounds. */
- DomainT first()const { return (*(_map.begin())).KEY_VALUE.first(); }
+ DomainT first()const { return (*(_map.begin())).first.first(); }
 
     /** Largest element of the map (wrt. the partial ordering on DomainT).
         last() does not exist for continuous datatypes and open interval
         bounds. */
- DomainT last()const { return (*(_map.rbegin())).KEY_VALUE.last(); }
+ DomainT last()const { return (*(_map.rbegin())).first.last(); }
 
 
     //==========================================================================
@@ -315,7 +315,7 @@
     {
         const_iterator it_ = _map.find(interval_type(key));
         return it_==end() ? neutron<codomain_type>::value()
- : it_->CONT_VALUE;
+ : it_->second;
     }
 
 
@@ -406,7 +406,7 @@
         for all keys in interval \c I in the map. */
     SubType& set(const segment_type& interval_value_pair)
     {
- erase(interval_value_pair.KEY_VALUE);
+ erase(interval_value_pair.first);
         that()->insert_(interval_value_pair);
         return *that();
     }
@@ -677,7 +677,7 @@
     {
         dom.clear();
         const_FOR_IMPLMAP(it_)
- dom += it_->KEY_VALUE;
+ dom += it_->first;
     }
 
     /* Sum of associated elements of the map */
@@ -726,8 +726,8 @@
     template <class Combiner>
     bool combine(iterator& it_, const codomain_type& co_val)
     {
- Combiner()(it_->CONT_VALUE, co_val);
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ Combiner()(it_->second, co_val);
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
         { this->_map.erase(it_); it_ = _map.end(); return false; }
         return true;
     }
@@ -753,9 +753,9 @@
         iterator inserted_
             = this->_map.insert(prior_, value_type(inter_val, Combiner::neutron()));
 
- if(inserted_->KEY_VALUE == inter_val && inserted_->CONT_VALUE == Combiner::neutron())
+ if(inserted_->first == inter_val && inserted_->second == Combiner::neutron())
         {
- Combiner()(inserted_->CONT_VALUE, co_val);
+ Combiner()(inserted_->second, co_val);
             return std::pair<iterator,bool>(inserted_, true);
         }
         else
@@ -772,7 +772,7 @@
         if(Traits::is_total)
         {
             iterator inserted_ = this->_map.insert(prior_, value_type(inter_val, Combiner::neutron()));
- Combiner()(inserted_->CONT_VALUE, co_val);
+ Combiner()(inserted_->second, co_val);
             return inserted_;
         }
         else
@@ -798,7 +798,7 @@
     ::contains(const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
                ::segment_type& sub_segment)const
 {
- interval_type sub_interval = sub_segment.KEY_VALUE;
+ interval_type sub_interval = sub_segment.first;
     if(sub_interval.empty())
         return true;
 
@@ -808,11 +808,11 @@
 
     const_iterator last_overlap = prior(exterior.second);
 
- if(!(sub_segment.CONT_VALUE == exterior.first->CONT_VALUE) )
+ if(!(sub_segment.second == exterior.first->second) )
         return false;
 
     return
- hull(exterior.first->KEY_VALUE, last_overlap->KEY_VALUE).contains(sub_interval)
+ hull(exterior.first->first, last_overlap->first).contains(sub_interval)
     && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
 }
 
@@ -855,7 +855,7 @@
 {
     difference_type length = neutron<difference_type>::value();
     const_FOR_IMPLMAP(it_)
- length += it_->KEY_VALUE.length();
+ length += it_->first.length();
     return length;
 }
 
@@ -926,7 +926,7 @@
     }
     else
     {
- interval_type sectant_interval = sectant.KEY_VALUE;
+ interval_type sectant_interval = sectant.first;
         if(sectant_interval.empty())
             return;
 
@@ -939,21 +939,21 @@
         if(is_set<CodomainT>::value)
             for(it_=first_; it_ != end_; it_++)
             {
- interval_type common_interval = it_->KEY_VALUE & sectant_interval;
+ interval_type common_interval = it_->first & sectant_interval;
                 if(!common_interval.empty())
                 {
- section.that()->add(value_type(common_interval, it_->CONT_VALUE));
- section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.CONT_VALUE));
+ section.that()->add(value_type(common_interval, it_->second));
+ section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.second));
                 }
             }
         else
             for(it_=first_; it_ != end_; it_++)
             {
- interval_type common_interval = it_->KEY_VALUE & sectant_interval;
+ interval_type common_interval = it_->first & sectant_interval;
                 if(!common_interval.empty())
                 {
- section.that()->add(value_type(common_interval, it_->CONT_VALUE) );
- section.that()->template add<codomain_combine>(value_type(common_interval, sectant.CONT_VALUE));
+ section.that()->add(value_type(common_interval, it_->second) );
+ section.that()->template add<codomain_combine>(value_type(common_interval, sectant.second));
                 }
             }
 
@@ -980,9 +980,9 @@
     iterator prior_ = section.end();
     for(typename ImplMapT::const_iterator it_=first_; it_ != end_; it_++)
     {
- interval_type common_interval = it_->KEY_VALUE & sectant_interval;
+ interval_type common_interval = it_->first & sectant_interval;
         if(!common_interval.empty())
- prior_ = section.that()->gap_insert<codomain_combine>(prior_, common_interval, it_->CONT_VALUE );
+ prior_ = section.that()->gap_insert<codomain_combine>(prior_, common_interval, it_->second );
     }
 }
 
@@ -1010,8 +1010,8 @@
     if(Traits::is_total && !Traits::absorbs_neutrons)
     {
         (*that()) += interval_value_pair;
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ ITL_FORALL(typename ImplMapT, it_, _map)
+ it_->second = neutron<codomain_type>::value();
 
         if(!is_interval_splitter<SubType>::value)
             join();
@@ -1019,13 +1019,13 @@
         return *that();
     }
 
- interval_type span = interval_value_pair.KEY_VALUE;
+ interval_type span = interval_value_pair.first;
 
     typename ImplMapT::const_iterator first_ = _map.lower_bound(span);
     typename ImplMapT::const_iterator end_ = _map.upper_bound(span);
 
     interval_type covered, left_over, common_interval;
- const codomain_type& x_value = interval_value_pair.CONT_VALUE;
+ const codomain_type& x_value = interval_value_pair.second;
     typename ImplMapT::const_iterator it_ = first_;
 
     interval_set<DomainT,Compare,Interval,Alloc> eraser;
@@ -1033,8 +1033,8 @@
 
     while(it_ != end_ )
     {
- const codomain_type& co_value = it_->CONT_VALUE;
- covered = (*it_++).KEY_VALUE;
+ const codomain_type& co_value = it_->second;
+ covered = (*it_++).first;
         //[a ... : span
         // [b ... : covered
         //[a b) : left_over
@@ -1099,8 +1099,8 @@
     if(Traits::is_total && !Traits::absorbs_neutrons)
     {
         (*that()) += operand;
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ ITL_FORALL(typename ImplMapT, it_, _map)
+ it_->second = neutron<codomain_type>::value();
 
         if(!is_interval_splitter<SubType>::value)
             join();
@@ -1127,8 +1127,8 @@
         add(*it_++);
 
     if(Traits::is_total && !Traits::absorbs_neutrons)
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ ITL_FORALL(typename ImplMapT, it_, _map)
+ it_->second = neutron<codomain_type>::value();
 
     return *that();
 }
@@ -1151,21 +1151,21 @@
 
     while(next_ != _map.end())
     {
- if( it_->KEY_VALUE.touches(next_->KEY_VALUE)
- && it_->CONT_VALUE == next_->CONT_VALUE )
+ if( it_->first.touches(next_->first)
+ && it_->second == next_->second )
         {
             iterator fst_mem = it_; // hold the fist member
             
             // Go on while touching members are found
             it_++; next_++;
             while( next_ != _map.end()
- && it_->KEY_VALUE.touches(next_->KEY_VALUE)
- && it_->CONT_VALUE == next_->CONT_VALUE )
+ && it_->first.touches(next_->first)
+ && it_->second == next_->second )
             { 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_->KEY_VALUE).extend(fst_mem->KEY_VALUE);
+ const_cast<interval_type&>(it_->first).extend(fst_mem->first);
             _map.erase(fst_mem, it_);
 
             it_++; next_=it_;
@@ -1188,9 +1188,9 @@
     std::string res("");
     const_FOR_IMPLMAP(it_) {
         std::string cur("(");
- cur += it_->KEY_VALUE.as_string();
+ cur += it_->first.as_string();
         cur += ",";
- cur += itl::to_string<CodomainT>::apply(it_->CONT_VALUE);
+ cur += itl::to_string<CodomainT>::apply(it_->second);
         cur += ")";
         res += cur;
     }
@@ -1208,7 +1208,7 @@
 {
     total = codomain_combine::neutron();
     const_FOR_IMPLMAP(it_)
- total += it_->CONT_VALUE;
+ total += it_->second;
 }
 
 
@@ -1221,7 +1221,7 @@
 {
     // I can do this only, because I am shure that the contents and the
     // ordering < on interval is invariant wrt. this transformation on bounds
- FOR_IMPLMAP(it_) const_cast<interval_type&>(it_->KEY_VALUE).as(bounded);
+ FOR_IMPLMAP(it_) const_cast<interval_type&>(it_->first).as(bounded);
 }
 
 
@@ -1245,18 +1245,18 @@
 
     iterator last_ = end_; --last_;
 
- interval_type left_resid = right_subtract(first_->KEY_VALUE, minuend);
- interval_type right_resid = left_subtract(last_ ->KEY_VALUE, minuend);
+ interval_type left_resid = right_subtract(first_->first, minuend);
+ interval_type right_resid = left_subtract(last_ ->first, minuend);
 
     if(first_ == last_ )
         if(!left_resid.empty())
         {
- const_cast<interval_type&>(first_->KEY_VALUE).right_subtract(minuend);
+ const_cast<interval_type&>(first_->first).right_subtract(minuend);
             if(!right_resid.empty())
- this->_map.insert(first_, value_type(right_resid, first_->CONT_VALUE));
+ this->_map.insert(first_, value_type(right_resid, first_->second));
         }
         else if(!right_resid.empty())
- const_cast<interval_type&>(first_->KEY_VALUE).left_subtract(minuend);
+ const_cast<interval_type&>(first_->first).left_subtract(minuend);
         else
             this->_map.erase(first_);
     else
@@ -1269,10 +1269,10 @@
         this->_map.erase(start_, stop_); //erase [start_, stop_)
 
         if(!left_resid.empty())
- const_cast<interval_type&>(first_->KEY_VALUE).right_subtract(minuend);
+ const_cast<interval_type&>(first_->first).right_subtract(minuend);
 
         if(!right_resid.empty())
- const_cast<interval_type&>(last_ ->KEY_VALUE).left_subtract(minuend);
+ const_cast<interval_type&>(last_ ->first).left_subtract(minuend);
     }
     return *that();
 }
@@ -1287,7 +1287,7 @@
 interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase(const interval_base_map& erasure)
 {
- const_FORALL(typename interval_base_map, value_pair_, erasure)
+ ITL_const_FORALL(typename interval_base_map, value_pair_, erasure)
         that()->erase_(*value_pair_);
 
     return *that();
@@ -1427,7 +1427,7 @@
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
                               Traits,Compare,Combine,Section,Interval,Alloc> map_type;
- const_FORALL(typename map_type, elem_, operand)
+ ITL_const_FORALL(typename map_type, elem_, operand)
         object.template add<inplace_min >(*elem_);
 
     return object;
@@ -1452,7 +1452,7 @@
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
                               Traits,Compare,Combine,Section,Interval,Alloc> map_type;
- const_FORALL(typename map_type, elem_, operand)
+ ITL_const_FORALL(typename map_type, elem_, operand)
         object.template add<inplace_max>(*elem_);
 
     return object;
@@ -1472,8 +1472,8 @@
     typedef interval_base_map<SubType,DomainT,CodomainT,
                               Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
     stream << "{";
- const_FORALL(typename IntervalMapT, it_, object)
- stream << "(" << it_->KEY_VALUE << "->" << it_->CONT_VALUE << ")";
+ ITL_const_FORALL(typename IntervalMapT, it_, object)
+ stream << "(" << it_->first << "->" << it_->second << ")";
 
     return stream << "}";
 }

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 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -731,7 +731,7 @@
 {
     typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> IntervalSetT;
     stream << "{";
- const_FORALL(typename IntervalSetT, it_, object)
+ ITL_const_FORALL(typename IntervalSetT, it_, object)
         stream << (*it_);
 
     return stream << "}";

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -103,7 +103,7 @@
         this->clear();
         // Can be implemented via _map.insert: Interval joining not necessary.
         iterator prior_ = this->_map.end();
- const_FORALL(typename base_map_type, it_, src)
+ ITL_const_FORALL(typename base_map_type, it_, src)
             prior_ = this->add(prior_, *it_);
     }
  
@@ -134,8 +134,8 @@
 private:
     bool insertable(const value_type& value)const
     {
- return !value.KEY_VALUE.empty()
- && !(Traits::absorbs_neutrons && value.CONT_VALUE == codomain_combine::neutron());
+ return !value.first.empty()
+ && !(Traits::absorbs_neutrons && value.second == codomain_combine::neutron());
     }
 
     iterator join_left(iterator& it_);
@@ -178,8 +178,8 @@
     ::joinable(const iterator& some, const iterator& next)const
 {
     // assert: next != end && some++ == next
- return some->KEY_VALUE.touches(next->KEY_VALUE)
- && some->CONT_VALUE == next->CONT_VALUE;
+ return some->first.touches(next->first)
+ && some->second == next->second;
 }
 
 
@@ -192,9 +192,9 @@
     // both left and right are in the map and they are neighbours
     BOOST_ASSERT(joinable(left_, right_));
 
- interval_type right_interval = right_->KEY_VALUE;
+ interval_type right_interval = right_->first;
     this->_map.erase(right_);
- const_cast<interval_type&>(left_->KEY_VALUE).extend(right_interval);
+ const_cast<interval_type&>(left_->first).extend(right_interval);
     
     return left_;
 }
@@ -208,9 +208,9 @@
     // both left and right are in the map and they are neighbours
     BOOST_ASSERT(joinable(left_, right_));
 
- interval_type right_interval = right_->KEY_VALUE;
+ interval_type right_interval = right_->first;
     this->_map.erase(right_);
- const_cast<interval_type&>(left_->KEY_VALUE).extend(right_interval);
+ const_cast<interval_type&>(left_->first).extend(right_interval);
     right_ = left_;
 
     return right_;
@@ -261,24 +261,24 @@
 inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_(const value_type& addend)
 {
- const interval_type& inter_val = addend.KEY_VALUE;
+ const interval_type& inter_val = addend.first;
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = addend.CONT_VALUE;
+ const CodomainT& co_val = addend.second;
     if(Traits::absorbs_neutrons && co_val==Combiner::neutron())
         return;
 
     std::pair<iterator,bool> insertion
         = this->template map_insert<Combiner>(inter_val, co_val);
 
- if(insertion.WAS_SUCCESSFUL)
- join_neighbours(insertion.ITERATOR);
+ if(insertion.second)
+ join_neighbours(insertion.first);
     else
     {
         // Detect the first and the end iterator of the collision sequence
         iterator first_ = this->_map.lower_bound(inter_val),
- last_ = insertion.ITERATOR;
+ last_ = insertion.first;
         //assert(end_ == this->_map.upper_bound(inter_val));
 
         iterator it_ = first_;
@@ -297,19 +297,19 @@
     interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_(iterator prior_, const value_type& addend)
 {
- const interval_type& inter_val = addend.KEY_VALUE;
+ const interval_type& inter_val = addend.first;
     if(inter_val.empty())
         return prior_;
 
- const CodomainT& co_val = addend.CONT_VALUE;
+ const CodomainT& co_val = addend.second;
     if(Traits::absorbs_neutrons && co_val==Combiner::neutron())
         return prior_;
 
     std::pair<iterator,bool> insertion
         = this->template map_insert<Combiner>(prior_, inter_val, co_val);
 
- if(insertion.WAS_SUCCESSFUL)
- return join_neighbours(insertion.ITERATOR);
+ if(insertion.second)
+ return join_neighbours(insertion.first);
     else
     {
         // Detect the first and the end iterator of the collision sequence
@@ -337,15 +337,15 @@
     // 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(first_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(first_->first, inter_val);
 
     if(!left_resid.empty())
     { // [------------ . . .
         // [prior) [left_resid---first_ --- . . .
         iterator prior_ = this->prior(first_);
- const_cast<interval_type&>(first_->KEY_VALUE).left_subtract(left_resid);
+ const_cast<interval_type&>(first_->first).left_subtract(left_resid);
         //NOTE: Only splitting
- this->_map.insert(prior_, value_type(left_resid, first_->CONT_VALUE));
+ this->_map.insert(prior_, value_type(left_resid, first_->second));
     }
 
     //POST:
@@ -362,7 +362,7 @@
     interval_type cur_interval;
     while(it_!=last_)
     {
- cur_interval = it_->KEY_VALUE ;
+ cur_interval = it_->first ;
         add_segment<Combiner>(x_rest, co_val, it_);
         // shrink interval
         x_rest.left_subtract(cur_interval);
@@ -375,7 +375,7 @@
 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_->KEY_VALUE);
+ interval_type lead_gap = right_subtract(inter_val, it_->first);
     if(!lead_gap.empty())
     {
         // [lead_gap--- . . .
@@ -388,8 +388,8 @@
 
     // . . . --------- . . . addend interval
     // [-- it_ --) has a common part with the first overval
- Combiner()(it_->CONT_VALUE, co_val);
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ Combiner()(it_->second, co_val);
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
         this->_map.erase(it_++);
     else
     {
@@ -406,7 +406,7 @@
     ::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
     iterator prior_ = this->prior(it_);
- interval_type cur_itv = it_->KEY_VALUE ;
+ interval_type cur_itv = it_->first ;
 
     interval_type lead_gap = right_subtract(inter_val, cur_itv);
     if(!lead_gap.empty())
@@ -422,9 +422,9 @@
     {
         // [----------------end_gap)
         // . . . -- it_ --)
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
         {
             this->_map.erase(it_);
             it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
@@ -446,9 +446,9 @@
         {
             // [---------------)
             // [-- it_ ---)
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
             {
                 this->_map.erase(it_);
                 it_ = prior_;
@@ -460,17 +460,17 @@
         {
             // [--------------)
             // [-- it_ --right_resid)
- const_cast<interval_type&>(it_->KEY_VALUE).right_subtract(right_resid);
+ const_cast<interval_type&>(it_->first).right_subtract(right_resid);
 
             //NOTE: This is NOT an insertion that has to take care for correct application of
             // 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_->CONT_VALUE));
+ iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
             join_right(insertion_);
 
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
             {
                 this->_map.erase(it_);
                 it_ = insertion_;
@@ -490,12 +490,12 @@
 void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_(const value_type& minuend)
 {
- interval_type inter_val = minuend.KEY_VALUE;
+ interval_type inter_val = minuend.first;
 
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = minuend.CONT_VALUE;
+ const CodomainT& co_val = minuend.second;
     if(Traits::absorbs_neutrons && co_val==Combiner::neutron())
         return;
 
@@ -519,13 +519,13 @@
 inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_front(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
- interval_type left_resid = right_subtract(it_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(it_->first, inter_val);
 
     if(!left_resid.empty())
     {
         iterator prior_ = this->prior(it_);
- const_cast<interval_type&>(it_->KEY_VALUE).left_subtract(left_resid);
- this->_map.insert(prior_, value_type(left_resid, it_->CONT_VALUE));
+ const_cast<interval_type&>(it_->first).left_subtract(left_resid);
+ this->_map.insert(prior_, value_type(left_resid, it_->second));
     }
 }
 
@@ -537,9 +537,9 @@
 {
     while(it_ != last_)
     {
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE==Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second==Combiner::neutron())
             this->_map.erase(it_++);
         else
         {
@@ -555,11 +555,11 @@
 inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
- interval_type right_resid = left_subtract(it_->KEY_VALUE, inter_val);
+ interval_type right_resid = left_subtract(it_->first, inter_val);
 
     if(right_resid.empty())
     {
- CodomainT& cur_val = it_->CONT_VALUE ;
+ CodomainT& cur_val = it_->second ;
         Combiner()(cur_val, co_val);
         if(Traits::absorbs_neutrons && cur_val==Combiner::neutron())
             this->_map.erase(it_);
@@ -568,10 +568,10 @@
     }
     else
     {
- const_cast<interval_type&>(it_->KEY_VALUE).right_subtract(right_resid);
- iterator next_ = this->_map.insert(it_, value_type(right_resid, it_->CONT_VALUE));
- Combiner()(it_->CONT_VALUE, co_val);
- if(Traits::absorbs_neutrons && it_->CONT_VALUE==Combiner::neutron())
+ const_cast<interval_type&>(it_->first).right_subtract(right_resid);
+ iterator next_ = this->_map.insert(it_, value_type(right_resid, it_->second));
+ Combiner()(it_->second, co_val);
+ if(Traits::absorbs_neutrons && it_->second==Combiner::neutron())
         {
             this->_map.erase(it_);
             join_right(next_);
@@ -593,23 +593,23 @@
 void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_(const value_type& addend)
 {
- interval_type inter_val = addend.KEY_VALUE;
+ interval_type inter_val = addend.first;
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = addend.CONT_VALUE;
+ const CodomainT& co_val = addend.second;
     if(Traits::absorbs_neutrons && co_val==codomain_combine::neutron())
         return;
 
     std::pair<iterator,bool> insertion = this->_map.insert(addend);
 
- if(insertion.WAS_SUCCESSFUL)
- join_neighbours(insertion.ITERATOR);
+ if(insertion.second)
+ join_neighbours(insertion.first);
     else
     {
         // Detect the first and the end iterator of the collision sequence
         iterator first_ = this->_map.lower_bound(inter_val),
- last_ = insertion.ITERATOR;
+ last_ = insertion.first;
         //assert((++last_) == this->_map.upper_bound(inter_val));
         iterator it_ = first_;
         insert_range(inter_val, co_val, it_, last_);
@@ -627,11 +627,11 @@
     if(prior_ != this->_map.end())
         --prior_;
     interval_type rest_interval = inter_val, left_gap, cur_itv;
- interval_type last_interval = last_ ->KEY_VALUE;
+ interval_type last_interval = last_ ->first;
 
     while(it_ != end_ )
     {
- cur_itv = it_->KEY_VALUE ;
+ cur_itv = it_->first ;
         left_gap = right_subtract(rest_interval, cur_itv);
 
         if(!left_gap.empty())
@@ -665,11 +665,11 @@
 void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase_(const value_type& minuend)
 {
- interval_type inter_val = minuend.KEY_VALUE;
+ interval_type inter_val = minuend.first;
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = minuend.CONT_VALUE;
+ const CodomainT& co_val = minuend.second;
     if(Traits::absorbs_neutrons && co_val==codomain_combine::neutron())
         return;
 
@@ -686,19 +686,19 @@
     if(first_ == last_)
     {
         // only for the last there can be a right_resid: a part of *it_ right of minuend
- interval_type right_resid = left_subtract(first_->KEY_VALUE, inter_val);
+ interval_type right_resid = left_subtract(first_->first, inter_val);
 
- if(first_->CONT_VALUE == co_val)
+ if(first_->second == co_val)
         {
- interval_type left_resid = right_subtract(first_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(first_->first, inter_val);
             if(!left_resid.empty())
             {
- const_cast<interval_type&>(first_->KEY_VALUE) = left_resid;
+ const_cast<interval_type&>(first_->first) = left_resid;
                 if(!right_resid.empty())
                     this->_map.insert(first_, value_type(right_resid, co_val));
             }
             else if(!right_resid.empty())
- const_cast<interval_type&>(first_->KEY_VALUE) = right_resid;
+ const_cast<interval_type&>(first_->first) = right_resid;
             else
                 this->_map.erase(first_);
         }
@@ -706,13 +706,13 @@
     else
     {
         // first AND NOT last
- if(first_->CONT_VALUE == co_val)
+ if(first_->second == co_val)
         {
- interval_type left_resid = right_subtract(first_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(first_->first, inter_val);
             if(left_resid.empty())
                 this->_map.erase(first_);
             else
- const_cast<interval_type&>(first_->KEY_VALUE) = left_resid;
+ const_cast<interval_type&>(first_->first) = left_resid;
         }
 
         erase_rest(inter_val, co_val, second_, last_);
@@ -725,20 +725,20 @@
     ::erase_rest(const interval_type& inter_val, const CodomainT& co_val,
                  iterator& it_, iterator& last_)
 {
- // For all intervals within loop: it_->KEY_VALUE are contained_in inter_val
+ // For all intervals within loop: it_->first are contained_in inter_val
     while(it_ != last_)
- if((*it_).CONT_VALUE == co_val)
+ if((*it_).second == co_val)
             this->_map.erase(it_++);
         else it_++;
 
     //erase_rear:
- if(it_->CONT_VALUE == co_val)
+ if(it_->second == co_val)
     {
- interval_type right_resid = left_subtract(it_->KEY_VALUE, inter_val);
+ interval_type right_resid = left_subtract(it_->first, inter_val);
         if(right_resid.empty())
             this->_map.erase(it_);
         else
- const_cast<interval_type&>(it_->KEY_VALUE) = right_resid;
+ const_cast<interval_type&>(it_->first) = right_resid;
     }
 }
 

Modified: sandbox/itl/boost/itl/interval_morphism.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_morphism.hpp (original)
+++ sandbox/itl/boost/itl/interval_morphism.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -16,7 +16,7 @@
         template <typename ElementContainerT, typename IntervalContainerT>
         void atomize(ElementContainerT& result, const IntervalContainerT& src)
         {
- const_FORALL(typename IntervalContainerT, itv_, src)
+ ITL_const_FORALL(typename IntervalContainerT, itv_, src)
             {
                 const typename IntervalContainerT::key_type& itv = IntervalContainerT::key_value(itv_);
                 typename IntervalContainerT::codomain_type coval = IntervalContainerT::codomain_value(itv_);
@@ -31,7 +31,7 @@
         template <typename IntervalContainerT, typename ElementContainerT>
         void cluster(IntervalContainerT& result, const ElementContainerT& src)
         {
- const_FORALL(typename ElementContainerT, element_, src)
+ ITL_const_FORALL(typename ElementContainerT, element_, src)
             {
                 const typename ElementContainerT::key_type& key = ElementContainerT::key_value(element_);
                 const typename ElementContainerT::data_type& data = ElementContainerT::data_value(element_);
@@ -64,7 +64,7 @@
             void operator()(JointType& joint, SplitType& split)
             {
                 split.join();
- FORALL(typename SplitType, split_, split)
+ ITL_FORALL(typename SplitType, split_, split)
                     joint.insert(*split_);
             }
         };
@@ -75,7 +75,7 @@
             void operator()(AbsorberType& absorber, EnricherType& enricher)
             {
                 enricher.absorb_neutrons();
- FORALL(typename EnricherType, enricher_, enricher)
+ ITL_FORALL(typename EnricherType, enricher_, enricher)
                     absorber.insert(*enricher_);
             }
         };

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -129,7 +129,7 @@
         this->clear();
         // Has to be implemented via add. there might be touching borders to be joined
         iterator prior_ = this->_set.end();
- const_FORALL(typename base_set_type, it_, src)
+ ITL_const_FORALL(typename base_set_type, it_, src)
             prior_ = this->add(prior_, *it_);
     }
 
@@ -229,13 +229,13 @@
 
     std::pair<iterator,bool> insertion = this->_set.insert(addend);
 
- if(insertion.WAS_SUCCESSFUL)
- handle_neighbours(insertion.ITERATOR);
+ if(insertion.second)
+ handle_neighbours(insertion.first);
     else
     {
         iterator first_ = this->_set.lower_bound(addend),
- last_ = insertion.ITERATOR,
- end_ = insertion.ITERATOR; ++end_;
+ last_ = insertion.first,
+ end_ = insertion.first; ++end_;
         //BOOST_ASSERT(end_ == this->_map.upper_bound(inter_val));
         iterator second_= first_; ++second_;
 

Modified: sandbox/itl/boost/itl/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/interval_set_algo.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -27,7 +27,7 @@
 
     size_type size = neutron<size_type>::value();
     size_type interval_size;
- const_FORALL(typename IntervalContainerT, it, object)
+ ITL_const_FORALL(typename IntervalContainerT, it, object)
     {
         interval_size = continuous_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
         if(interval_size == std::numeric_limits<size_type>::infinity())
@@ -45,7 +45,7 @@
     typedef typename IntervalContainerT::interval_type interval_type;
 
     size_type size = neutron<size_type>::value();
- const_FORALL(typename IntervalContainerT, it, object)
+ ITL_const_FORALL(typename IntervalContainerT, it, object)
         size += discrete_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
     return size;
 }

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -209,7 +209,7 @@
     {
         const_iterator it = find(key);
         return it==end() ? neutron<codomain_type>::value()
- : it->CONT_VALUE;
+ : it->second;
     }
 
     //==========================================================================
@@ -244,7 +244,7 @@
 
     std::pair<iterator,bool> insert(const value_type& value_pair)
     {
- if(Traits::absorbs_neutrons && value_pair.CONT_VALUE == codomain_combine::neutron())
+ if(Traits::absorbs_neutrons && value_pair.second == codomain_combine::neutron())
             return std::pair<iterator,bool>(end(),true);
         else
             return base_type::insert(value_pair);
@@ -252,7 +252,7 @@
 
     /** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
     map& set(const element_type& key_value_pair)
- { (*this)[key_value_pair.KEY_VALUE] = key_value_pair.CONT_VALUE; return *this; }
+ { (*this)[key_value_pair.first] = key_value_pair.second; return *this; }
 
     /** erase \c key_value_pair from the map.
         Erase only if, the exact value content \c val is stored for the given key. */
@@ -357,8 +357,8 @@
     void domain(set_type& domain_set)const
     {
         typename set_type::iterator prior_ = domain_set.end();
- const_FORALL_THIS(it_)
- prior_ = domain_set.insert(prior_, it_->KEY_VALUE);
+ ITL_const_FORALL_THIS(it_)
+ prior_ = domain_set.insert(prior_, it_->first);
     }
 
 private:
@@ -382,27 +382,27 @@
 map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
     map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::add(const value_type& val)
 {
- if(Traits::absorbs_neutrons && val.CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && val.second == Combiner::neutron())
         return *this;
 
     std::pair<iterator, bool> insertion;
     if(Traits::is_total)
     {
         CodomainT added_val = Combiner::neutron();
- Combiner()(added_val, val.CONT_VALUE);
- insertion = insert(value_type(val.KEY_VALUE, added_val));
+ Combiner()(added_val, val.second);
+ insertion = insert(value_type(val.first, added_val));
     }
     else // Existential case
         insertion = insert(val);
 
- if( insertion.WAS_SUCCESSFUL )
+ if( insertion.second )
         return *this;
     else
     {
- iterator it = insertion.ITERATOR;
- Combiner()((*it).CONT_VALUE, val.CONT_VALUE);
+ iterator it = insertion.first;
+ Combiner()((*it).second, val.second);
 
- if(Traits::absorbs_neutrons && (*it).CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && (*it).second == Combiner::neutron())
             erase(it);
 
         return *this;
@@ -416,12 +416,12 @@
     map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
     ::add(iterator prior_, const value_type& val)
 {
- if(Traits::absorbs_neutrons && val.CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && val.second == Combiner::neutron())
         return prior_;
 
- iterator inserted_ = insert(prior_, value_type(val.KEY_VALUE, Combiner::neutron()));
- Combiner()(inserted_->CONT_VALUE, val.CONT_VALUE);
- if(Traits::absorbs_neutrons && inserted_->CONT_VALUE == Combiner::neutron())
+ iterator inserted_ = insert(prior_, value_type(val.first, Combiner::neutron()));
+ Combiner()(inserted_->second, val.second);
+ if(Traits::absorbs_neutrons && inserted_->second == Combiner::neutron())
     {
         erase(inserted_);
         return prior_;
@@ -439,11 +439,11 @@
 map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
     map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::subtract(const value_type& val)
 {
- iterator it_ = find(val.KEY_VALUE);
+ iterator it_ = find(val.first);
     if(it_ != end())
     {
- Combiner()((*it_).CONT_VALUE, val.CONT_VALUE);
- if(Traits::absorbs_neutrons && (*it_).CONT_VALUE == codomain_combine::neutron())
+ Combiner()((*it_).second, val.second);
+ if(Traits::absorbs_neutrons && (*it_).second == codomain_combine::neutron())
             erase(it_);
     }
     return *this;
@@ -459,12 +459,12 @@
     map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
     ::erase(const value_type& value_pair)
 {
- if(Traits::absorbs_neutrons && value_pair.CONT_VALUE == codomain_combine::neutron())
+ if(Traits::absorbs_neutrons && value_pair.second == codomain_combine::neutron())
         return 0; // neutrons are never contained 'substantially'
                   // only 'virually'.
 
- iterator it_ = find(value_pair.KEY_VALUE);
- if(it_ != end() && value_pair.CONT_VALUE == it_->CONT_VALUE)
+ iterator it_ = find(value_pair.first);
+ if(it_ != end() && value_pair.second == it_->second)
     {
         erase(it_);
         return 1;
@@ -489,7 +489,7 @@
     }
     else
     {
- const_iterator it_ = find(sectant.KEY_VALUE);
+ const_iterator it_ = find(sectant.first);
         if(it_ != end())
         {
             section.add(*it_);
@@ -539,7 +539,7 @@
     const_iterator sec_ = common_lwb_;
     while(sec_ != common_upb_)
     {
- const_iterator it_ = find(sec_->KEY_VALUE);
+ const_iterator it_ = find(sec_->first);
         if(it_ != end())
         {
             section.add(*it_);
@@ -583,11 +583,11 @@
 std::string map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::as_string()const
 {
     std::string repr;
- const_FORALL_THIS(it) {
+ ITL_const_FORALL_THIS(it) {
         std::string elem("(");
- elem += to_string<DomainT>::apply((*it).KEY_VALUE);
+ elem += to_string<DomainT>::apply((*it).first);
         elem += "->";
- elem += to_string<CodomainT>::apply((*it).CONT_VALUE);
+ elem += to_string<CodomainT>::apply((*it).second);
         elem += ")";
 
         repr += elem;
@@ -632,7 +632,7 @@
 {
     typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
 
- const_FORALL(typename map_type, elem_, addend)
+ ITL_const_FORALL(typename map_type, elem_, addend)
         object.insert(*elem_);
 
     return object;
@@ -646,7 +646,7 @@
 {
     typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
 
- const_FORALL(typename map_type, elem_, erasure)
+ ITL_const_FORALL(typename map_type, elem_, erasure)
         object.erase(*elem_);
 
     return object;
@@ -660,7 +660,7 @@
 {
     typedef set<DomainT,Compare,Alloc> operand_type;
 
- const_FORALL(typename operand_type, elem_, erasure)
+ ITL_const_FORALL(typename operand_type, elem_, erasure)
         object.erase(*elem_);
 
     return object;
@@ -834,7 +834,7 @@
              const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
 {
     typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- const_FORALL(typename ObjectT, it_, operand)
+ ITL_const_FORALL(typename ObjectT, it_, operand)
         object.subtract(*it_);
 
     return object;
@@ -1051,8 +1051,8 @@
 {
     typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
     stream << "{";
- const_FORALL(typename ObjectT, it, object)
- stream << "(" << it->KEY_VALUE << "->" << it->CONT_VALUE << ")";
+ ITL_const_FORALL(typename ObjectT, it, object)
+ stream << "(" << it->first << "->" << it->second << ")";
 
     return stream << "}";
 }

Modified: sandbox/itl/boost/itl/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/map_algo.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -34,10 +34,10 @@
     typename MapType::const_iterator sub_ = sub.begin(), super_;
     while(sub_ != sub.end())
     {
- super_ = super.find((*sub_).KEY_VALUE);
+ super_ = super.find((*sub_).first);
         if(super_ == super.end())
             return false;
- else if(!(sub_->CONT_VALUE == super_->CONT_VALUE))
+ else if(!(sub_->second == super_->second))
             return false;
         sub_++;
     }
@@ -122,26 +122,26 @@
         cur_x2_ = x2_;
         std::pair<typename MapType::iterator,bool> insertion
             = result.insert(*x2_++);
- if(!insertion.WAS_SUCCESSFUL)
+ if(!insertion.second)
         {
- //result.erase(insertion.ITERATOR);
+ //result.erase(insertion.first);
             if(is_set<typename MapType::codomain_type>::value)
             {
- typename MapType::iterator res_ = insertion.ITERATOR;
- typename MapType::codomain_type common_value = res_->CONT_VALUE;
- typename MapType::key_type key_value = res_->KEY_VALUE;
- typename MapType::inverse_codomain_intersect()(common_value, cur_x2_->CONT_VALUE);
+ typename MapType::iterator res_ = insertion.first;
+ typename MapType::codomain_type common_value = res_->second;
+ typename MapType::key_type key_value = res_->first;
+ typename MapType::inverse_codomain_intersect()(common_value, cur_x2_->second);
                 result.subtract(*res_);
                 result.add(typename MapType::value_type(key_value, common_value));
             }
             else
- result.subtract(*insertion.ITERATOR);
+ result.subtract(*insertion.first);
         }
     }
 
     if(is_total<MapType>::value && !absorbs_neutrons<MapType>::value)
- FORALL(typename MapType, it_, result)
- it_->CONT_VALUE = neutron<typename MapType::codomain_type>::value();
+ ITL_FORALL(typename MapType, it_, result)
+ it_->second = neutron<typename MapType::codomain_type>::value();
 }
 
 
@@ -150,7 +150,7 @@
 typename MapType::const_iterator next_proton(typename MapType::const_iterator& iter_, const MapType& object)
 {
     while( iter_ != object.end()
- && iter_->CONT_VALUE == neutron<typename MapType::codomain_type>::value())
+ && iter_->second == neutron<typename MapType::codomain_type>::value())
         ++iter_;
 
     return iter_;
@@ -172,7 +172,7 @@
 
     while(left_ != left.end() && right_ != right.end())
     {
- if(!(left_->KEY_VALUE == right_->KEY_VALUE && left_->CONT_VALUE == right_->CONT_VALUE))
+ if(!(left_->first == right_->first && left_->second == right_->second))
             return false;
 
         ++left_;

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 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -152,13 +152,13 @@
 
     std::pair<iterator,bool> insertion = this->_set.insert(addend);
 
- if(insertion.WAS_SUCCESSFUL)
- handle_neighbours(insertion.ITERATOR);
+ if(insertion.second)
+ handle_neighbours(insertion.first);
     else
     {
         iterator first_ = this->_set.lower_bound(addend),
- last_ = insertion.ITERATOR,
- end_ = insertion.ITERATOR; end_ ++;
+ last_ = insertion.first,
+ end_ = insertion.first; end_ ++;
         //BOOST_ASSERT(end_ == this->_map.upper_bound(inter_val));
         iterator second_= first_; ++second_;
 

Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -266,8 +266,8 @@
 set<DomainT,Compare,Alloc>::flip(const element_type& operand)
 {
     std::pair<iterator,bool> insertion = insert(operand);
- if(!insertion.WAS_SUCCESSFUL)
- erase(insertion.ITERATOR);
+ if(!insertion.second)
+ erase(insertion.first);
 
     return *this;
 }

Modified: sandbox/itl/boost/itl/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/set_algo.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -195,8 +195,8 @@
             while(x2_ != x2.end())
             {
                 std::pair<typename SetType::iterator,bool> insertion = result.insert(*x2_++);
- if(!insertion.WAS_SUCCESSFUL)
- result.erase(insertion.ITERATOR);
+ if(!insertion.second)
+ result.erase(insertion.first);
             }
         }
 

Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -163,22 +163,22 @@
 inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_(const value_type& addend)
 {
- interval_type inter_val = addend.KEY_VALUE;
+ interval_type inter_val = addend.first;
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = addend.CONT_VALUE;
+ const CodomainT& co_val = addend.second;
     if(Traits::absorbs_neutrons && co_val==Combiner::neutron())
         return;
 
     std::pair<iterator,bool> insertion
         = this->template map_insert<Combiner>(inter_val, co_val);
 
- if(!insertion.WAS_SUCCESSFUL)
+ if(!insertion.second)
     {
         // Detect the first and the end iterator of the collision sequence
         iterator first_ = this->_map.lower_bound(inter_val),
- last_ = insertion.ITERATOR;
+ last_ = insertion.first;
         //assert(end_ == this->_map.upper_bound(inter_val));
 
         iterator it_ = first_;
@@ -196,19 +196,19 @@
     split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_(iterator prior_, const value_type& addend)
 {
- interval_type inter_val = addend.KEY_VALUE;
+ interval_type inter_val = addend.first;
     if(inter_val.empty())
         return prior_;
 
- const CodomainT& co_val = addend.CONT_VALUE;
+ const CodomainT& co_val = addend.second;
     if(Traits::absorbs_neutrons && co_val==Combiner::neutron())
         return prior_;
 
     std::pair<iterator,bool> insertion
         = this->template map_insert<Combiner>(prior_, inter_val, co_val);
 
- if(insertion.WAS_SUCCESSFUL)
- return insertion.ITERATOR;
+ if(insertion.second)
+ return insertion.first;
     else
     {
         // Detect the first and the end iterator of the collision sequence
@@ -236,15 +236,15 @@
     // 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(first_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(first_->first, inter_val);
 
     if(!left_resid.empty())
     { // [------------ . . .
         // [left_resid---first_ --- . . .
         iterator prior_ = this->prior(first_);
- const_cast<interval_type&>(first_->KEY_VALUE).left_subtract(left_resid);
+ const_cast<interval_type&>(first_->first).left_subtract(left_resid);
         //NOTE: Only splitting
- iterator insertion_ = this->_map.insert(prior_, value_type(left_resid, first_->CONT_VALUE));
+ iterator insertion_ = this->_map.insert(prior_, value_type(left_resid, first_->second));
     }
 
     //POST:
@@ -261,7 +261,7 @@
     interval_type cur_interval;
     while(it_!=last_)
     {
- cur_interval = it_->KEY_VALUE ;
+ cur_interval = it_->first ;
         add_segment<Combiner>(x_rest, co_val, it_);
         // shrink interval
         x_rest.left_subtract(cur_interval);
@@ -274,7 +274,7 @@
 inline void split_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_->KEY_VALUE);
+ interval_type lead_gap = right_subtract(inter_val, it_->first);
     if(!lead_gap.empty())
         // [lead_gap--- . . .
         // [prior_) [-- it_ ...
@@ -282,8 +282,8 @@
 
     // . . . --------- . . . addend interval
     // [-- it_ --) has a common part with the first overval
- Combiner()(it_->CONT_VALUE, co_val);
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ Combiner()(it_->second, co_val);
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
         this->_map.erase(it_++);
     else
         ++it_;
@@ -297,7 +297,7 @@
     ::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
     iterator prior_ = this->prior(it_);
- interval_type cur_itv = (*it_).KEY_VALUE ;
+ interval_type cur_itv = (*it_).first ;
 
     interval_type lead_gap = right_subtract(inter_val, cur_itv);
     if(!lead_gap.empty())
@@ -311,9 +311,9 @@
     {
         // [---------------end_gap)
         // [-- it_ --)
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
         {
             this->_map.erase(it_);
             it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
@@ -330,9 +330,9 @@
         {
             // [---------------)
             // [-- it_ ---)
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
             {
                 this->_map.erase(it_);
                 it_ = prior_;
@@ -342,16 +342,16 @@
         {
             // [--------------)
             // [-- it_ --right_resid)
- const_cast<interval_type&>(it_->KEY_VALUE).right_subtract(right_resid);
+ const_cast<interval_type&>(it_->first).right_subtract(right_resid);
 
             //NOTE: This is NOT an insertion that has to take care for correct application of
             // 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_->CONT_VALUE));
+ iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
 
- Combiner()(it_->CONT_VALUE, co_val);
+ Combiner()(it_->second, co_val);
 
- if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
+ if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
                 this->_map.erase(it_);
 
             it_ = insertion_;
@@ -370,12 +370,12 @@
 inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_(const value_type& minuend)
 {
- interval_type inter_val = minuend.KEY_VALUE;
+ interval_type inter_val = minuend.first;
 
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = minuend.CONT_VALUE;
+ const CodomainT& co_val = minuend.second;
     if(Traits::absorbs_neutrons && co_val==Combiner::neutron())
         return;
 
@@ -398,15 +398,15 @@
 inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_front(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
- interval_type left_resid = right_subtract(it_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(it_->first, inter_val);
 
     if(!left_resid.empty())
     {
         iterator prior_ = it_;
         if(prior_ != this->_map.begin())
             --prior_;
- const_cast<interval_type&>(it_->KEY_VALUE).left_subtract(left_resid);
- this->_map.insert(prior_, value_type(left_resid, it_->CONT_VALUE));
+ const_cast<interval_type&>(it_->first).left_subtract(left_resid);
+ this->_map.insert(prior_, value_type(left_resid, it_->second));
     }
 }
 
@@ -419,8 +419,8 @@
 {
     while(it_ != last_)
     {
- Combiner()(it_->CONT_VALUE, co_val);
- if(Traits::absorbs_neutrons && it_->CONT_VALUE==Combiner::neutron())
+ Combiner()(it_->second, co_val);
+ if(Traits::absorbs_neutrons && it_->second==Combiner::neutron())
             this->_map.erase(it_++);
         else ++it_;
     }
@@ -432,11 +432,11 @@
 inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
 {
- interval_type right_resid = left_subtract(it_->KEY_VALUE, inter_val);
+ interval_type right_resid = left_subtract(it_->first, inter_val);
 
     if(right_resid.empty())
     {
- CodomainT& cur_val = it_->CONT_VALUE ;
+ CodomainT& cur_val = it_->second ;
         Combiner()(cur_val, co_val);
         if(Traits::absorbs_neutrons && cur_val==Combiner::neutron())
             this->_map.erase(it_);
@@ -444,10 +444,10 @@
     else
     { // . . . ---)
         // . . . ---right_resid) : split it_
- const_cast<interval_type&>(it_->KEY_VALUE).right_subtract(right_resid);
- iterator next_ = this->_map.insert(it_, value_type(right_resid, it_->CONT_VALUE));
- Combiner()(it_->CONT_VALUE, co_val);
- if(Traits::absorbs_neutrons && it_->CONT_VALUE==Combiner::neutron())
+ const_cast<interval_type&>(it_->first).right_subtract(right_resid);
+ iterator next_ = this->_map.insert(it_, value_type(right_resid, it_->second));
+ Combiner()(it_->second, co_val);
+ if(Traits::absorbs_neutrons && it_->second==Combiner::neutron())
             this->_map.erase(it_);
     }
 }
@@ -461,21 +461,21 @@
 void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_(const value_type& addend)
 {
- interval_type inter_val = addend.KEY_VALUE;
+ interval_type inter_val = addend.first;
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = addend.CONT_VALUE;
+ const CodomainT& co_val = addend.second;
     if(Traits::absorbs_neutrons && co_val==codomain_combine::neutron())
         return;
 
     std::pair<iterator,bool> insertion = this->_map.insert(addend);
 
- if(!insertion.WAS_SUCCESSFUL)
+ if(!insertion.second)
     {
         // Detect the first and the end iterator of the collision sequence
         iterator first_ = this->_map.lower_bound(inter_val),
- last_ = insertion.ITERATOR;
+ last_ = insertion.first;
         //assert((++last_) == this->_map.upper_bound(inter_val));
         iterator it_ = first_;
         insert_range(inter_val, co_val, it_, last_);
@@ -493,11 +493,11 @@
     if(prior_ != this->_map.end())
         --prior_;
     interval_type rest_interval = inter_val, left_gap, cur_itv;
- interval_type last_interval = last_ ->KEY_VALUE;
+ interval_type last_interval = last_ ->first;
 
     while(it_ != end_ )
     {
- cur_itv = it_->KEY_VALUE ;
+ cur_itv = it_->first ;
         left_gap = right_subtract(rest_interval, cur_itv);
 
         if(!left_gap.empty())
@@ -523,11 +523,11 @@
 inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase_(const value_type& minuend)
 {
- interval_type inter_val = minuend.KEY_VALUE;
+ interval_type inter_val = minuend.first;
     if(inter_val.empty())
         return;
 
- const CodomainT& co_val = minuend.CONT_VALUE;
+ const CodomainT& co_val = minuend.second;
     if(Traits::absorbs_neutrons && co_val==codomain_combine::neutron())
         return;
 
@@ -544,19 +544,19 @@
     if(first_ == last_)
     {
         // only for the last there can be a right_resid: a part of *it_ right of minuend
- interval_type right_resid = left_subtract(first_->KEY_VALUE, inter_val);
+ interval_type right_resid = left_subtract(first_->first, inter_val);
 
- if(first_->CONT_VALUE == co_val)
+ if(first_->second == co_val)
         {
- interval_type left_resid = right_subtract(first_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(first_->first, inter_val);
             if(!left_resid.empty())
             {
- const_cast<interval_type&>(first_->KEY_VALUE) = left_resid;
+ const_cast<interval_type&>(first_->first) = left_resid;
                 if(!right_resid.empty())
                     this->_map.insert(first_, value_type(right_resid, co_val));
             }
             else if(!right_resid.empty())
- const_cast<interval_type&>(first_->KEY_VALUE) = right_resid;
+ const_cast<interval_type&>(first_->first) = right_resid;
             else
                 this->_map.erase(first_);
         }
@@ -564,13 +564,13 @@
     else
     {
         // first AND NOT last
- if(first_->CONT_VALUE == co_val)
+ if(first_->second == co_val)
         {
- interval_type left_resid = right_subtract(first_->KEY_VALUE, inter_val);
+ interval_type left_resid = right_subtract(first_->first, inter_val);
             if(left_resid.empty())
                 this->_map.erase(first_);
             else
- const_cast<interval_type&>(first_->KEY_VALUE) = left_resid;
+ const_cast<interval_type&>(first_->first) = left_resid;
         }
 
         erase_rest(inter_val, co_val, second_, last_);
@@ -583,20 +583,20 @@
     ::erase_rest(const interval_type& inter_val, const CodomainT& co_val,
                  iterator& it_, iterator& last_)
 {
- // For all intervals within loop: it_->KEY_VALUE are contained_in inter_val
+ // For all intervals within loop: it_->first are contained_in inter_val
     while(it_ != last_)
- if((*it_).CONT_VALUE == co_val)
+ if((*it_).second == co_val)
             this->_map.erase(it_++);
         else it_++;
 
     //erase_rear:
- if(it_->CONT_VALUE == co_val)
+ if(it_->second == co_val)
     {
- interval_type right_resid = left_subtract(it_->KEY_VALUE, inter_val);
+ interval_type right_resid = left_subtract(it_->first, inter_val);
         if(right_resid.empty())
             this->_map.erase(it_);
         else
- const_cast<interval_type&>(it_->KEY_VALUE) = right_resid;
+ const_cast<interval_type&>(it_->first) = right_resid;
     }
 }
 

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 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -151,10 +151,10 @@
 
     std::pair<iterator,bool> insertion = this->_set.insert(addend);
 
- if(!insertion.WAS_SUCCESSFUL)
+ if(!insertion.second)
     {
         iterator first_ = this->_set.lower_bound(addend),
- last_ = insertion.ITERATOR;
+ last_ = insertion.first;
         //BOOST_ASSERT(next(last_) == this->_set.upper_bound(inter_val));
 
         iterator it_ = first_;

Modified: sandbox/itl/boost/itl_xt/episode_product.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/episode_product.hpp (original)
+++ sandbox/itl/boost/itl_xt/episode_product.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -108,7 +108,7 @@
         const_iterator epiSet_ = find(type);
         if(epiSet_ == this->end())
             return NULL;
- else return *((*epiSet_).CONT_VALUE.begin());
+ else return *((*epiSet_).second.begin());
     }
 
     EpisodePTD getLast(typename TypeDomain::DomainET type)const
@@ -116,7 +116,7 @@
         const_iterator epiSet_ = find(type);
         if(epiSet_ == this->end())
             return NULL;
- else return *((*epiSet_).CONT_VALUE.rbegin());
+ else return *((*epiSet_).second.rbegin());
     }
 
     EpisodeSetTD* getEpisodeSetPtr(typename TypeDomain::DomainET type)
@@ -124,7 +124,7 @@
         iterator epiSet_ = find(type);
         if(epiSet_ == this->end())
             return NULL;
- else return &((*epiSet_).CONT_VALUE);
+ else return &((*epiSet_).second);
     }
     
     int size(typename TypeDomain::DomainET type)const
@@ -132,7 +132,7 @@
         const_iterator epiSet_ = find(type);
         if(epiSet_ == this->end())
             return 0;
- else return (*epiSet_).CONT_VALUE.size();
+ else return (*epiSet_).second.size();
     }
         
     bool insert(EpisodePTD pEpisode)
@@ -140,18 +140,18 @@
         EpisodeSetTD sglSet;
         sglSet.insert(pEpisode);
         typename TypeDomain::DomainET type = pEpisode->type();
- return base_type::insert(value_type(type,sglSet)).WAS_SUCCESSFUL;
+ return base_type::insert(value_type(type,sglSet)).second;
     }
 
     void leftAlignedEpisodes(episode_product& syncProd, const TimeT& start)
     {
- const_FORALL_THIS(elem_)
+ ITL_const_FORALL_THIS(elem_)
         {
- TypeDomain type = (*elem_).KEY_VALUE;
- EpisodeSetTD& epiSet = (*elem_).KEY_VALUE;
+ TypeDomain type = (*elem_).first;
+ EpisodeSetTD& epiSet = (*elem_).first;
             
             EpisodeSetTD syncSet;
- const_FORALL(typename EpisodeSetTD, epi_, epiSet)
+ ITL_const_FORALL(typename EpisodeSetTD, epi_, epiSet)
             {
                 if((*epi_)->interval().first()==start)
                     syncSet.insert(*epi_);
@@ -170,13 +170,13 @@
             return std::string("");
         else
         {
- std::string str( TypeDomain::as_string((*it).KEY_VALUE) );
- str += ("{"+((*it).CONT_VALUE).as_string()+"}");
+ std::string str( TypeDomain::as_string((*it).first) );
+ str += ("{"+((*it).second).as_string()+"}");
             it++;
             
             while(it != this->end()) {
- str += ", "; str += TypeDomain::as_string((*it).KEY_VALUE);
- str += ("{"+((*it).CONT_VALUE).as_string()+"}");
+ str += ", "; str += TypeDomain::as_string((*it).first);
+ str += ("{"+((*it).second).as_string()+"}");
                 it++;
             }
             return str;
@@ -221,7 +221,7 @@
     {
         const_iterator epiSet_ = find(type);
         if(epiSet_==end()) return NULL;
- else return *((*epiSet_).CONT_VALUE.begin());
+ else return *((*epiSet_).second.begin());
     }
 
     int size()const { return BaseTD::size(); }
@@ -230,7 +230,7 @@
     {
         const_iterator epiSet_ = find(type);
         if(epiSet_==end()) return 0;
- else return (*epiSet_).CONT_VALUE.size();
+ else return (*epiSet_).second.size();
     }
     
     
@@ -240,7 +240,7 @@
         EpisodeSetTD sglSet;
         sglSet.insert(pEpisode);
         TypeDomain::DomainET type = pEpisode->type();
- return BaseTD::insert(value_type(type,sglSet)).WAS_SUCCESSFUL;
+ return BaseTD::insert(value_type(type,sglSet)).second;
     }
 
     std::string as_string()const
@@ -251,13 +251,13 @@
         if(it==end()) return std::string("");
         else
         {
- std::string str( TypeDomain::as_string((*it).KEY_VALUE) );
- str += ("{"+((*it).CONT_VALUE).as_string()+"}");
+ std::string str( TypeDomain::as_string((*it).first) );
+ str += ("{"+((*it).second).as_string()+"}");
             it++;
             
             while(it != end()) {
- str += ", "; str += TypeDomain::as_string((*it).KEY_VALUE);
- str += ("{"+((*it).CONT_VALUE).as_string()+"}");
+ str += ", "; str += TypeDomain::as_string((*it).first);
+ str += ("{"+((*it).second).as_string()+"}");
                 it++;
             }
             return str;
@@ -278,9 +278,9 @@
 
     while(lhs_ != lhs.end())
     {
- if(!((*lhs_).KEY_VALUE == (*rhs_).KEY_VALUE))
+ if(!((*lhs_).first == (*rhs_).first))
             return false;
- else if (!((*lhs_).CONT_VALUE == (*rhs_).CONT_VALUE))
+ else if (!((*lhs_).second == (*rhs_).second))
             return false;
 
         lhs_++; rhs_++;

Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -110,7 +110,7 @@
 void MapGentorT<MapTV>::last(MapTV& x)const
 {
     x.clear();
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
         x += *it;
 }
 
@@ -122,13 +122,13 @@
     SampleTypeTD perm;
 
     NumberGentorT<int> intGentor;
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor(2) ) perm.push_back(*it);
         else perm.push_front(*it);
     }
 
- const_FORALL(typename SampleTypeTD, pit, perm)
+ ITL_const_FORALL(typename SampleTypeTD, pit, perm)
         x += *pit;
 }
 
@@ -145,7 +145,7 @@
     NumberGentorT<unsigned> intGentor;
     x.clear();
     int coin = intGentor.some(2); // gives 0 or 1
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor.some(2) ) sam.push_back(*it);
         else sam.push_front(*it);

Modified: sandbox/itl/boost/itl_xt/prefix_set.cpp
==============================================================================
--- sandbox/itl/boost/itl_xt/prefix_set.cpp (original)
+++ sandbox/itl/boost/itl_xt/prefix_set.cpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -67,11 +67,11 @@
 void prefix_set::insert(const std::string& val)
 {
     pair<iterator, bool> insertion = m_.insert(val);
- if(!insertion.WAS_SUCCESSFUL)
+ if(!insertion.second)
     {
- if(val.size() < (*insertion.ITERATOR).size())
+ if(val.size() < (*insertion.first).size())
         {
- m_.erase(insertion.ITERATOR);
+ m_.erase(insertion.first);
             insert(val);
         }
     }

Modified: sandbox/itl/boost/itl_xt/seqgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/seqgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/seqgentor.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -99,7 +99,7 @@
 void SeqGentorT<SeqTV>::last(SeqTV& x)const
 {
     x.clear();
- const_FORALL(typename SampleTypeTD, it, m_sample) x.insert(*it);
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample) x.insert(*it);
 }
 
 template <class SeqTV>
@@ -110,13 +110,13 @@
     SampleTypeTD perm;
 
     NumberGentorT<int> intGentor;
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor(2) ) perm.push_back(*it);
         else perm.push_front(*it);
     }
 
- const_FORALL(typename SampleTypeTD, pit, perm) x.insert(*pit);
+ ITL_const_FORALL(typename SampleTypeTD, pit, perm) x.insert(*pit);
 }
 
 
@@ -132,7 +132,7 @@
     NumberGentorT<unsigned> intGentor;
     x.clear();
     int coin = intGentor.some(2); // gives 0 or 1
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor.some(2) ) sam.push_back(*it);
         else sam.push_front(*it);

Modified: sandbox/itl/boost/itl_xt/setgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/setgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/setgentor.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -100,7 +100,7 @@
 void SetGentorT<SetTV>::last(SetTV& x)const
 {
     x.clear();
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
         x += *it;
 }
 
@@ -112,13 +112,13 @@
     SampleTypeTD perm;
 
     NumberGentorT<int> intGentor;
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor(2) ) perm.push_back(*it);
         else perm.push_front(*it);
     }
 
- const_FORALL(typename SampleTypeTD, pit, perm)
+ ITL_const_FORALL(typename SampleTypeTD, pit, perm)
         x += *pit;
 }
 
@@ -135,7 +135,7 @@
     NumberGentorT<unsigned> intGentor;
     x.clear();
     int coin = intGentor.some(2); // gives 0 or 1
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor.some(2) ) sam.push_back(*it);
         else sam.push_front(*it);

Modified: sandbox/itl/boost/itl_xt/string_set.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_set.hpp (original)
+++ sandbox/itl/boost/itl_xt/string_set.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -98,7 +98,7 @@
     void string_set<Compare>::selectSet(string_set& selectees, StringSelectorFPD selector)const
     {
         selectees.clear();
- const_FORALL_THIS(it)
+ ITL_const_FORALL_THIS(it)
             selectees.insert(((*it).*selector)());
     }
 }} // namespace boost itl

Modified: sandbox/itl/boost/itl_xt/string_sheet.cpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_sheet.cpp (original)
+++ sandbox/itl/boost/itl_xt/string_sheet.cpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -49,7 +49,7 @@
 
 void string_sheet::fprint(FILE* file, const char* sep)const
 {
- const_FORALL_THIS(row_)
+ ITL_const_FORALL_THIS(row_)
     {
         const string_list& row = (*row_);
         fprintf(file, "%s\n", row.join(sep).c_str());

Modified: sandbox/itl/boost/itl_xt/tuple_computer.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/tuple_computer.hpp (original)
+++ sandbox/itl/boost/itl_xt/tuple_computer.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -251,8 +251,8 @@
     template <int VarCount, class CounterT>
     void tuple_computer_base<VarCount, CounterT>::addDomain(tuple_set_type& domain)const
     {
- const_FORALL_THIS(tupel_)
- domain.insert((*tupel_).KEY_VALUE);
+ ITL_const_FORALL_THIS(tupel_)
+ domain.insert((*tupel_).first);
     }
 
 
@@ -261,8 +261,8 @@
     {
         std::pair<typename ImplMapTD::iterator,bool> insertion = m_map.insert(val);
 
- if(!insertion.WAS_SUCCESSFUL)
- (*insertion.ITERATOR).CONT_VALUE += val.CONT_VALUE;
+ if(!insertion.second)
+ (*insertion.first).second += val.second;
     }
 
 
@@ -307,7 +307,7 @@
 
         void alignFor(const tuple_set_type& domain)
         {
- const_FORALL(typename tuple_set_type, it_, domain)
+ ITL_const_FORALL(typename tuple_set_type, it_, domain)
                 this->insert(*it_, CounteeT());
         }
 
@@ -317,7 +317,7 @@
     void amount_tuple_computer<VarCount, CounterT>::load(const tuple_computer_interface<VarCount>& srcI)
     {
         const amount_tuple_computer& src = dynamic_cast<const amount_tuple_computer&>(srcI);
- const_FORALL(typename amount_tuple_computer, it_, src)
+ ITL_const_FORALL(typename amount_tuple_computer, it_, src)
             this->insert(*it_);
     }
 
@@ -356,7 +356,7 @@
 
         void alignFor(const tuple_set_type& domain)
         {
- const_FORALL(typename tuple_set_type, it_, domain)
+ ITL_const_FORALL(typename tuple_set_type, it_, domain)
                 insert(*it_, counter_type());
         }
 
@@ -366,7 +366,7 @@
     void date_tuple_computer<VarCount,TimeT,CounteeT>::load(const tuple_computer_interface<VarCount>& srcI)
     {
         const date_tuple_computer& src = dynamic_cast<const date_tuple_computer&>(srcI);
- const_FORALL(typename date_tuple_computer, it_, src)
+ ITL_const_FORALL(typename date_tuple_computer, it_, src)
             insert(*it_);
     }
 
@@ -415,7 +415,7 @@
 
         void alignFor(const tuple_set_type& domain)
         {
- const_FORALL(typename tuple_set_type, it_, domain)
+ ITL_const_FORALL(typename tuple_set_type, it_, domain)
                 insert(*it_, counter_type());
         }
     };
@@ -425,7 +425,7 @@
     void interval_tuple_computer<VarCount,TimeT,CounteeT>::load(const tuple_computer_interface<VarCount>& srcI)
     {
         const interval_tuple_computer& src = dynamic_cast<const interval_tuple_computer&>(srcI);
- const_FORALL(typename interval_tuple_computer, it_, src)
+ ITL_const_FORALL(typename interval_tuple_computer, it_, src)
             insert(*it_);
     }
 
@@ -433,12 +433,12 @@
     void interval_tuple_computer<VarCount,TimeT,CounteeT>::insertDateMap(const var_tuple_type tup, const DateMapTD& date)
     {
         counter_type itvCounter;
- const_FORALL(typename DateMapTD, date_, date)
+ ITL_const_FORALL(typename DateMapTD, date_, date)
         {
             itvCounter.insert(
                 counter_type::value_type(
- counter_type::interval_type((*date_).KEY_VALUE, (*date_).KEY_VALUE),
- (*date_).CONT_VALUE
+ counter_type::interval_type((*date_).first, (*date_).first),
+ (*date_).second
                     )
                 );
         }
@@ -457,12 +457,12 @@
         typedef interval_base_map<SubType, ItvDomTV, CodomTV> ItvMapTD;
 
         itvMap.clear();
- const_FORALL(typename DateMapTD, date_, dateMap)
+ ITL_const_FORALL(typename DateMapTD, date_, dateMap)
         {
             itvMap.insert(
                 ItvMapTD::value_type(
- ItvMapTD::interval_type((*date_).KEY_VALUE, (*date_).KEY_VALUE),
- (*date_).CONT_VALUE
+ ItvMapTD::interval_type((*date_).first, (*date_).first),
+ (*date_).second
                     )
                 );
         }
@@ -487,7 +487,7 @@
 
         ItvMapTD* aux = itvMap.cons();
         //JODO OPTI: optimize using the ordering: if intervalls are beyond borders we can terminate
- const_FORALL(typename DiscItvSetTD, itv_, grid)
+ ITL_const_FORALL(typename DiscItvSetTD, itv_, grid)
         {
             itvMap.intersect(*aux, *itv_);
             gridSums.insert(ItvMapTD::value_type(*itv_, (*aux).volume()));

Modified: sandbox/itl/boost/itl_xt/var_permutation.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_permutation.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_permutation.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -240,7 +240,7 @@
         master.consequent_permutation(conseq, unseq);
 
         perm.clear();
- const_FORALL(ListTD, it_, conseq)
+ ITL_const_FORALL(ListTD, it_, conseq)
             perm.add(*it_);
     }
 

Modified: sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -76,7 +76,7 @@
             if(count_ == m_Omissions.end())
                 return 0;
             else
- return (*count_).CONT_VALUE;
+ return (*count_).second;
         }
 
     protected:

Modified: sandbox/itl/boost/itl_xt/var_tuple_order.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_tuple_order.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_tuple_order.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -93,7 +93,7 @@
     template <typename VarTupleT>
     bool itl::var_tuple_order<VarTupleT>::operator() (const VarTupleT& x1, const VarTupleT& x2)const
     {
- FORALL_VEC(permIdx, m_Permutation)
+ ITL_FORALL_VEC(permIdx, m_Permutation)
         {
             int idx = m_Permutation[permIdx];
 
@@ -125,7 +125,7 @@
     template <typename VarTupleT>
     VarEnumTD itl::var_tuple_order<VarTupleT>::indexOfFirstDifference(const VarTupleT& x1, const VarTupleT& x2)const
     {
- FORALL_VEC(permIdx, m_Permutation)
+ ITL_FORALL_VEC(permIdx, m_Permutation)
         {
             int idx = m_Permutation[permIdx];
 

Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -89,13 +89,13 @@
             int valid_count = 1;
             double avg_evaluation_time = 0.0;
             long instance_count = 0;
- FORALL(ValidationCounterT, it, _frequencies)
+ ITL_FORALL(ValidationCounterT, it, _frequencies)
             {
- long law_validation_count = it->CONT_VALUE.count();
+ long law_validation_count = it->second.count();
                 double avg_law_evaluation_time =
- it->CONT_VALUE.time()/(law_validation_count);
+ it->second.time()/(law_validation_count);
                 printf("%3d %-58s%9ld%7.0lf\n",
- valid_count, it->KEY_VALUE.c_str(), law_validation_count, avg_law_evaluation_time);
+ valid_count, it->first.c_str(), law_validation_count, avg_law_evaluation_time);
 
                 avg_evaluation_time += avg_law_evaluation_time;
                 instance_count += law_validation_count;
@@ -109,16 +109,16 @@
                     avg_evaluation_time_per_law, " ", instance_count, avg_evaluation_time_per_law);
 
             int violation_count = 1;
- FORALL(ViolationMapT, it, _violations)
+ ITL_FORALL(ViolationMapT, it, _violations)
             {
- printf("%3d %-66s%8d\n", violation_count, it->KEY_VALUE.c_str(), it->CONT_VALUE.getViolationsCount());
+ printf("%3d %-66s%8d\n", violation_count, it->first.c_str(), it->second.getViolationsCount());
                 violation_count++;
             }
             if(!_violations.empty())
                 std::cout << "------------------------------------------------------------------------------" << std::endl;
- FORALL(ViolationMapT, it, _violations)
+ ITL_FORALL(ViolationMapT, it, _violations)
             {
- PolyLawViolations violas = it->CONT_VALUE;
+ PolyLawViolations violas = it->second;
                 violas.reportFirst();
             }
             if(!_violations.empty())
@@ -129,9 +129,9 @@
         {
             FILE* fp = fopen(filename.c_str(), "w");
             int valid_count = 1;
- FORALL(ValidationCounterT, it, _frequencies)
+ ITL_FORALL(ValidationCounterT, it, _frequencies)
             {
- fprintf(fp, "%3d %-66s\n", valid_count, it->KEY_VALUE.c_str());
+ fprintf(fp, "%3d %-66s\n", valid_count, it->first.c_str());
                 valid_count++;
             }
         }

Modified: sandbox/itl/boost/validate/laws/law_violations.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/law_violations.hpp (original)
+++ sandbox/itl/boost/validate/laws/law_violations.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -112,7 +112,7 @@
 
         LawViolationsI& operator += (const LawViolationsI& rhs)
         {
- const_FORALL(typename ViolationSet, vio_,
+ ITL_const_FORALL(typename ViolationSet, vio_,
                 dynamic_cast<const LawViolations<LawT>*>(rhs.getLawViolations())->_violations)
                 insert(*vio_);
 

Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -1072,7 +1072,7 @@
 
     typename IntervalMapT::const_iterator found = map_a.find(MK_v(6));
 
- BOOST_CHECK_EQUAL( found->CONT_VALUE, MK_u(3) );
+ BOOST_CHECK_EQUAL( found->second, MK_u(3) );
     BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
 
     found = map_a.find(MK_v(5));

Modified: sandbox/itl/libs/itl/test/test_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_map.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -32,7 +32,7 @@
 
     typename MapT::const_iterator found = map_a.find(MK_v(6));
 
- BOOST_CHECK_EQUAL( found->CONT_VALUE, MK_u(3) );
+ BOOST_CHECK_EQUAL( found->second, MK_u(3) );
     BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
 
     found = map_a.find(MK_v(5));

Modified: sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp 2009-09-07 03:54:40 EDT (Mon, 07 Sep 2009)
@@ -86,7 +86,7 @@
 void polygon_gentor<PolygonT>::last(PolygonT& x)const
 {
     x.clear();
- const_FORALL(typename SampleTypeTD, it, m_sample) x.insert(*it);
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample) x.insert(*it);
 }
 
 template <class PolygonT>
@@ -97,13 +97,13 @@
     SampleTypeTD perm;
 
     NumberGentorT<int> intGentor;
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor(2) ) perm.push_back(*it);
         else perm.push_front(*it);
     }
 
- const_FORALL(typename SampleTypeTD, pit, perm) x.insert(*pit);
+ ITL_const_FORALL(typename SampleTypeTD, pit, perm) x.insert(*pit);
 }
 
 
@@ -181,7 +181,7 @@
 void polygon_set_gentor<PolygonSetT>::last(PolygonSetT& x)const
 {
     x.clear();
- const_FORALL(typename SampleTypeTD, it, m_sample) x.insert(*it);
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample) x.insert(*it);
 }
 
 template <class PolygonSetT>
@@ -192,13 +192,13 @@
     SampleTypeTD perm;
 
     NumberGentorT<int> intGentor;
- const_FORALL(typename SampleTypeTD, it, m_sample)
+ ITL_const_FORALL(typename SampleTypeTD, it, m_sample)
     {
         if( 0==intGentor(2) ) perm.push_back(*it);
         else perm.push_front(*it);
     }
 
- const_FORALL(typename SampleTypeTD, pit, perm) x.insert(*pit);
+ ITL_const_FORALL(typename SampleTypeTD, pit, perm) x.insert(*pit);
 }
 
 


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk