|
|
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