|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65417 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/functions boost/itl_xt boost/validate/std/algorithm libs/itl/test libs/itl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2010-09-14 05:17:50
Author: jofaber
Date: 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
New Revision: 65417
URL: http://svn.boost.org/trac/boost/changeset/65417
Log:
Refactoring: Rewrite of equivalences and orderings. Extraction of element iterator functions. Adaption of related tests. Stable{msvc-9.0, gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/continuous_interval.hpp | 2
sandbox/itl/boost/itl/detail/element_iterator.hpp | 1
sandbox/itl/boost/itl/functions.hpp | 42 +++++++
sandbox/itl/boost/itl/functions/associative_interval_container.hpp | 113 ++++++++++++++++++++
sandbox/itl/boost/itl/interval_base_map.hpp | 225 ---------------------------------------
sandbox/itl/boost/itl/interval_base_set.hpp | 80 -------------
sandbox/itl/boost/itl_xt/interval_bitset.hpp | 59 +++++++++-
sandbox/itl/boost/validate/std/algorithm/copy.hpp | 12 +-
sandbox/itl/boost/validate/std/algorithm/find.hpp | 24 ++--
sandbox/itl/boost/validate/std/algorithm/relation.hpp | 20 +-
sandbox/itl/boost/validate/std/algorithm/set_algo.hpp | 32 ++--
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 6
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 10
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 8
14 files changed, 269 insertions(+), 365 deletions(-)
Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -156,7 +156,7 @@
struct is_continuous_interval<continuous_interval<DomainT,Compare> >
{
typedef is_continuous_interval<continuous_interval<DomainT,Compare> > type;
- BOOST_STATIC_CONSTANT(bool, value = is_continuous<DomainT>::value);
+ BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare>
Modified: sandbox/itl/boost/itl/detail/element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_iterator.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_iterator.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -246,6 +246,7 @@
>
{
public:
+ typedef element_iterator type;
typedef SegmentIteratorT segment_iterator;
typedef typename SegmentIteratorT::value_type segment_type;
typedef typename first_element<segment_type>::type interval_type;
Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -181,6 +181,16 @@
}
//------------------------------------------------------------------------------
+template<class LeftT, class RightT>
+typename enable_if< is_concept_compatible<is_interval_map, LeftT, RightT>,
+ bool >::type
+is_protonic_equal(const LeftT& left, const RightT& right)
+{
+ return Map::lexicographical_protonic_equal(left, right);
+}
+
+
+
//==============================================================================
//= Addition
@@ -205,7 +215,7 @@
template<class Type>
typename enable_if<is_interval_set<Type>, typename Type::iterator>::type
add(Type& object, typename Type::iterator prior,
- const typename Type::segment_type& operand)
+ const typename Type::segment_type& operand)
{
return Interval_Set::add(object, prior, operand);
}
@@ -1521,10 +1531,38 @@
, mpl::not_<absorbs_neutrons<Type> > >, Type>::type&
absorb_neutrons(Type& object)
{
- typedef typename Type::segment_type segment_type;
+ typedef typename Type::segment_type segment_type;
return itl::erase_if(content_is_neutron<segment_type>(), object);
}
+//==============================================================================
+//= Streaming
+//==============================================================================
+template<class CharType, class CharTraits, class Type>
+typename enable_if<is_interval_set<Type>,
+ std::basic_ostream<CharType, CharTraits> >::type&
+operator << (std::basic_ostream<CharType, CharTraits>& stream, const Type& object)
+{
+ stream << "{";
+ ITL_const_FORALL(typename Type, it_, object)
+ stream << (*it_);
+
+ return stream << "}";
+}
+
+template<class CharType, class CharTraits, class Type>
+typename enable_if<is_interval_map<Type>,
+ std::basic_ostream<CharType, CharTraits> >::type&
+operator << (std::basic_ostream<CharType, CharTraits>& stream, const Type& object)
+{
+ stream << "{";
+ ITL_const_FORALL(typename Type, it_, object)
+ stream << "(" << it_->first << "->" << it_->second << ")";
+
+ return stream << "}";
+}
+
+
}} // namespace itl boost
#endif
Modified: sandbox/itl/boost/itl/functions/associative_interval_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions/associative_interval_container.hpp (original)
+++ sandbox/itl/boost/itl/functions/associative_interval_container.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -70,6 +70,119 @@
}
+//==========================================================================
+//= Element iterator related
+//==========================================================================
+//--------------------------------------------------------------------------
+//- Forward
+//--------------------------------------------------------------------------
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_iterator>::type
+elements_begin(Type& object)
+{
+ return typename Type::element_iterator(object.begin());
+}
+
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_iterator>::type
+elements_end(Type& object)
+{
+ return typename Type::element_iterator(object.end());
+}
+
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_const_iterator>::type
+elements_begin(const Type& object)
+{
+ return typename Type::element_const_iterator(object.begin());
+}
+
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_const_iterator>::type
+elements_end(const Type& object)
+{
+ return typename Type::element_const_iterator(object.end());
+}
+
+//--------------------------------------------------------------------------
+//- Reverse
+//--------------------------------------------------------------------------
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_reverse_iterator>::type
+elements_rbegin(Type& object)
+{
+ return typename Type::element_reverse_iterator(object.rbegin());
+}
+
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_reverse_iterator>::type
+elements_rend(Type& object)
+{
+ return typename Type::element_reverse_iterator(object.rend());
+}
+
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_const_reverse_iterator>::type
+elements_rbegin(const Type& object)
+{
+ return typename Type::element_const_reverse_iterator(object.rbegin());
+}
+
+template<class Type>
+typename enable_if
+<mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_continuous_interval<typename Type::interval_type> > >,
+typename Type::element_const_reverse_iterator>::type
+elements_rend(const Type& object)
+{
+ return typename Type::element_const_reverse_iterator(object.rend());
+}
+
+//==============================================================================
+//= Equivalences and Orderings
+//==============================================================================
+
+template<class Type>
+inline typename enable_if<is_interval_container<Type>, bool>::type
+operator == (const Type& left, const Type& right)
+{
+ return Set::lexicographical_equal(left, right);
+}
+
+
+template<class Type>
+inline typename enable_if<is_interval_container<Type>, bool>::type
+operator < (const Type& left, const Type& right)
+{
+ typedef typename Type::segment_compare segment_compare;
+ return std::lexicographical_compare(
+ left.begin(), left.end(), right.begin(), right.end(),
+ segment_compare()
+ );
+}
+
+
}} // namespace itl boost
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -128,9 +128,10 @@
//- Associated types: Functors
//--------------------------------------------------------------------------
/// Comparison functor for domain values
- typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+ typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+ typedef ITL_COMPARE_DOMAIN(Compare,segment_type) segment_compare;
/// Combine functor for codomain value aggregation
- typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
+ typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
/// Inverse Combine functor for codomain value aggregation
typedef typename inverse<codomain_combine>::type inverse_codomain_combine;
/// Intersection functor for codomain values
@@ -498,45 +499,6 @@
const_reverse_iterator rbegin()const { return _map.rbegin(); }
const_reverse_iterator rend()const { return _map.rend(); }
- iterator prior(iterator it_)
- { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
-
- const_iterator prior(const_iterator it_)const
- { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
-
-
- //==========================================================================
- //= Element iterator related
- //==========================================================================
- element_iterator elements_begin(){ return element_iterator(this->begin()); }
- element_iterator elements_end() { return element_iterator(this->end()); }
- element_const_iterator elements_begin()const{ return element_const_iterator(this->begin()); }
- element_const_iterator elements_end() const{ return element_const_iterator(this->end()); }
-
- element_reverse_iterator elements_rbegin(){ return element_reverse_iterator(this->rbegin()); }
- element_reverse_iterator elements_rend() { return element_reverse_iterator(this->rend()); }
- element_const_reverse_iterator elements_rbegin()const{ return element_const_reverse_iterator(this->rbegin()); }
- element_const_reverse_iterator elements_rend() const{ return element_const_reverse_iterator(this->rend()); }
-
- //==========================================================================
- //= Domain, sum
- //==========================================================================
-
- /** Gives the domain of the map as interval set */
- // template
- // <
- // template
- // <class DomT, ITL_COMPARE Comp, ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
- // class IntervalSet
- // >
- // void domain(IntervalSet<DomainT,Compare,Interval,Alloc>& dom)const
- // {
- //itl::domain(dom, *that());
- // //CL dom.clear();
- // //const_FOR_IMPLMAP(it_)
- // // dom += it_->first;
- // }
-
//==========================================================================
//= Algorithm unifiers
//==========================================================================
@@ -563,187 +525,6 @@
} ;
-//==============================================================================
-//= Equivalences and Orderings
-//==============================================================================
-//-----------------------------------------------------------------------------
-// equality
-//-----------------------------------------------------------------------------
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{
- return Set::lexicographical_equal(lhs, rhs);
-}
-
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool operator != (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{
- return !(lhs == rhs);
-}
-
-
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{
- return Map::lexicographical_protonic_equal(lhs, rhs);
-}
-
-
-template
-<
- class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc,
- template
- <
- class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, ITL_INTERVAL(ITL_COMPARE), ITL_ALLOC
- >
- class IntervalMap
->
-bool is_protonic_equal
-(
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& left,
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& right
-)
-{
- return Map::lexicographical_protonic_equal(left, right);
-}
-
-
-
-//-----------------------------------------------------------------------------
-// order
-//-----------------------------------------------------------------------------
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool operator < (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{
- return std::lexicographical_compare(
- lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare),CodomainT> >()//NOTE DESIGN TTP: Why template template parameter Compare is needed
- );
-}
-
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool operator > (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{ return rhs < lhs; }
-
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool operator <= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{ return !(lhs > rhs); }
-
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-inline bool operator >= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
-{ return !(lhs < rhs); }
-
-//-----------------------------------------------------------------------------
-// min, max
-//-----------------------------------------------------------------------------
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc>&
-min_assign
-(
- interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc>& operand
-)
-{
- typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc> map_type;
- ITL_const_FORALL(typename map_type, elem_, operand)
- object.template _add<inplace_min >(*elem_);
-
- return object;
-}
-
-template
-<
- class SubType,
- class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
->
-interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc>&
-max_assign
-(
- interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc>& operand
-)
-{
- typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc> map_type;
- ITL_const_FORALL(typename map_type, elem_, operand)
- object.template _add<inplace_max>(*elem_);
-
- return object;
-}
-
-//---------------------------------------------------------------------------------
-
-template<class CharType, class CharTraits,
- class SubType, class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-std::basic_ostream<CharType, CharTraits>& operator <<
- (std::basic_ostream<CharType, CharTraits>& stream,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,
- Compare,Combine,Section,Interval,Alloc>& object)
-{
- typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
- stream << "{";
- ITL_const_FORALL(typename IntervalMapT, it_, object)
- stream << "(" << it_->first << "->" << it_->second << ")";
-
- return stream << "}";
-}
-
-
//-----------------------------------------------------------------------------
// type traits
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -174,9 +174,10 @@
//- Associated types: Order
//--------------------------------------------------------------------------
/// Comparison functor for domain values
- typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+ typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+ typedef ITL_COMPARE_DOMAIN(Compare,segment_type) segment_compare;
/// Comparison functor for intervals
- typedef exclusive_less_than<interval_type> interval_compare;
+ typedef exclusive_less_than<interval_type> interval_compare;
/// Comparison functor for keys
typedef exclusive_less_than<interval_type> key_compare;
@@ -531,19 +532,6 @@
{ return _set.equal_range(interval); }
//==========================================================================
- //= Element iterator related
- //==========================================================================
- element_iterator elements_begin(){ return element_iterator(this->begin()); }
- element_iterator elements_end() { return element_iterator(this->end()); }
- element_const_iterator elements_begin()const{ return element_const_iterator(this->begin()); }
- element_const_iterator elements_end() const{ return element_const_iterator(this->end()); }
-
- element_reverse_iterator elements_rbegin(){ return element_reverse_iterator(this->rbegin()); }
- element_reverse_iterator elements_rend() { return element_reverse_iterator(this->rend()); }
- element_const_reverse_iterator elements_rbegin()const{ return element_const_reverse_iterator(this->rbegin()); }
- element_const_reverse_iterator elements_rend() const{ return element_const_reverse_iterator(this->rend()); }
-
- //==========================================================================
//= Algorithm unifiers
//==========================================================================
@@ -570,68 +558,6 @@
} ;
-//==============================================================================
-//= Equivalences and Orderings
-//==============================================================================
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline bool operator == (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
-{
- return Set::lexicographical_equal(lhs, rhs);
-}
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline bool operator != (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
-{ return !(lhs == rhs); }
-
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline bool operator < (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
-{
- return std::lexicographical_compare(
- lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >()//NOTE DESIGN TTP: Why Compare needs to be ttp
- );
-}
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline bool operator > (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
-{ return rhs < lhs; }
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline bool operator <= (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
-{ return !(lhs > rhs); }
-
-template<class SubType,
- class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline bool operator >= (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
-{ return !(lhs < rhs); }
-
-template<class CharType, class CharTraits,
- class SubType, class DomainT,
- ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-std::basic_ostream<CharType, CharTraits>& operator <<
- (std::basic_ostream<CharType, CharTraits>& stream,
- const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object)
-{
- typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> IntervalSetT;
- stream << "{";
- ITL_const_FORALL(typename IntervalSetT, it_, object)
- stream << (*it_);
-
- return stream << "}";
-}
-
//-----------------------------------------------------------------------------
// type traits
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl_xt/interval_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/interval_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/interval_bitset.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -294,7 +294,7 @@
};
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::PartsT
interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::partition
(
@@ -348,7 +348,7 @@
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
bool interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::contains(const segment_type& segment)const
{
if(segment.empty())
@@ -374,7 +374,7 @@
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::size_type
interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::cardinality()const
{
@@ -397,7 +397,7 @@
}
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::show_matrix(const char off_on[2])const
{
typename interval_bitmap_type::const_iterator iter = _map.begin();
@@ -410,7 +410,52 @@
}
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+//------------------------------------------------------------------------------
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_iterator
+elements_begin(interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_begin(); }
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_iterator
+elements_end(interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_end(); }
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_const_iterator
+elements_begin(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_begin(); }
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_const_iterator
+elements_end(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_end(); }
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_reverse_iterator
+elements_rbegin(interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_rbegin(); }
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_reverse_iterator
+elements_rend(interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_rend(); }
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_const_reverse_iterator
+elements_rbegin(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_rbegin(); }
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::element_const_reverse_iterator
+elements_rend(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{ return object.elements_rend(); }
+
+//------------------------------------------------------------------------------
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
bool is_element_equal(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& left,
const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& right)
{ return left == right; }
@@ -487,8 +532,8 @@
const interval_bitset<DomainT, BitSetT>& clustered)
{
typedef interval_bitset<DomainT, BitSetT> InterBitsetT;
- typename InterBitsetT::element_const_iterator bit_ = clustered.elements_begin();
- while(bit_ != clustered.elements_end())
+ typename InterBitsetT::element_const_iterator bit_ = elements_begin(clustered);
+ while(bit_ != elements_end(clustered))
atomized.insert(*bit_++);
}
};
Modified: sandbox/itl/boost/validate/std/algorithm/copy.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/copy.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/copy.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -30,7 +30,7 @@
void operator()(const SourceT& source, TargetT& target)const
{
- std::copy(source.elements_begin(), source.elements_end(),
+ std::copy(elements_begin(source), elements_end(source),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
@@ -50,7 +50,7 @@
void operator()(const SourceT& source, TargetT& target)
{
- std::copy(source.elements_rbegin(), source.elements_rend(),
+ std::copy(elements_rbegin(source), elements_rend(source),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
@@ -72,7 +72,7 @@
void operator()(const SourceT& source, TargetT& target)
{
- std::reverse_copy(source.elements_begin(), source.elements_end(),
+ std::reverse_copy(elements_begin(source), elements_end(source),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
@@ -92,7 +92,7 @@
void operator()(const SourceT& source, TargetT& target)
{
- std::reverse_copy(source.elements_rbegin(), source.elements_rend(),
+ std::reverse_copy(elements_rbegin(source), elements_rend(source),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
@@ -117,7 +117,7 @@
void operator()(const SourceT& source, TargetT& target)
{
fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
- std::copy_backward(source.elements_begin(), source.elements_end(), target.end());
+ std::copy_backward(elements_begin(source), elements_end(source), target.end());
}
static std::string struct_abbreviation(){ return "cpyb_f"; }
@@ -138,7 +138,7 @@
void operator()(const SourceT& source, TargetT& target)
{
fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
- std::copy_backward(source.elements_rbegin(), source.elements_rend(), target.end());
+ std::copy_backward(elements_rbegin(source), elements_rend(source), target.end());
}
static std::string struct_abbreviation(){ return "cpyb_b"; }
Modified: sandbox/itl/boost/validate/std/algorithm/find.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/find.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/find.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -42,8 +42,8 @@
TargetT operator()(const SegmentalT& source)const
{
typename SegmentalT::element_const_iterator found
- = std::find(source.elements_begin(), source.elements_end(), _comparand);
- if(found == source.elements_end())
+ = std::find(elements_begin(source), elements_end(source), _comparand);
+ if(found == elements_end(source))
return neutron<TargetT>::value();
else
return *found;
@@ -81,8 +81,8 @@
TargetT operator()(const SegmentalT& source)const
{
typename SegmentalT::element_const_reverse_iterator found
- = std::find(source.elements_rbegin(), source.elements_rend(), _comparand);
- if(found == source.elements_rend())
+ = std::find(elements_rbegin(source), elements_rend(source), _comparand);
+ if(found == elements_rend(source))
return neutron<TargetT>::value();
else
return *found;
@@ -122,8 +122,8 @@
TargetT operator()(const SegmentalT& source)const
{
typename SegmentalT::element_const_iterator found
- = std::lower_bound(source.elements_begin(), source.elements_end(), _comparand);
- if(found == source.elements_end())
+ = std::lower_bound(elements_begin(source), elements_end(source), _comparand);
+ if(found == elements_end(source))
return neutron<TargetT>::value();
else
return *found;
@@ -161,8 +161,8 @@
TargetT operator()(const SegmentalT& source)const
{
typename SegmentalT::element_const_reverse_iterator found
- = std::lower_bound(source.elements_rbegin(), source.elements_rend(), _comparand);
- if(found == source.elements_rend())
+ = std::lower_bound(elements_rbegin(source), elements_rend(source), _comparand);
+ if(found == elements_rend(source))
return neutron<TargetT>::value();
else
return *found;
@@ -202,8 +202,8 @@
TargetT operator()(const SegmentalT& source)const
{
typename SegmentalT::element_const_iterator found
- = std::upper_bound(source.elements_begin(), source.elements_end(), _comparand);
- if(found == source.elements_end())
+ = std::upper_bound(elements_begin(source), elements_end(source), _comparand);
+ if(found == elements_end(source))
return neutron<TargetT>::value();
else
return *found;
@@ -241,8 +241,8 @@
TargetT operator()(const SegmentalT& source)const
{
typename SegmentalT::element_const_reverse_iterator found
- = std::upper_bound(source.elements_rbegin(), source.elements_rend(), _comparand);
- if(found == source.elements_rend())
+ = std::upper_bound(elements_rbegin(source), elements_rend(source), _comparand);
+ if(found == elements_rend(source))
return neutron<TargetT>::value();
else
return *found;
Modified: sandbox/itl/boost/validate/std/algorithm/relation.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/relation.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/relation.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -39,7 +39,7 @@
{
target = false;
if(left.size() <= right.size())
- target = std::equal(left.elements_begin(), left.elements_end(), right.elements_begin());
+ target = std::equal(elements_begin(left), elements_end(left), elements_begin(right));
}
static std::string struct_abbreviation(){ return "==f"; }
@@ -61,7 +61,7 @@
{
target = false;
if(left.size() <= right.size())
- target = std::equal(left.elements_rbegin(), left.elements_rend(), right.elements_rbegin());
+ target = std::equal(elements_rbegin(left), elements_rend(left), elements_rbegin(right));
}
static std::string struct_abbreviation(){ return "==b"; }
@@ -88,8 +88,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = std::lexicographical_compare
- (left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end());
+ (elements_begin(left), elements_end(left),
+ elements_begin(right), elements_end(right));
}
static std::string struct_abbreviation(){ return "<L_f"; }
@@ -110,8 +110,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = std::lexicographical_compare
- (left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend());
+ (elements_rbegin(left), elements_rend(left),
+ elements_rbegin(right), elements_rend(right));
}
static std::string struct_abbreviation(){ return "<L_b"; }
@@ -133,8 +133,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
- target = std::includes(left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end());
+ target = std::includes(elements_begin(left), elements_end(left),
+ elements_begin(right), elements_end(right));
}
static std::string struct_abbreviation(){ return "C=f"; }
@@ -154,8 +154,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
- target = std::includes(left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend());
+ target = std::includes(elements_rbegin(left), elements_rend(left),
+ elements_rbegin(right), elements_rend(right));
}
static std::string struct_abbreviation(){ return "C=b"; }
Modified: sandbox/itl/boost/validate/std/algorithm/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/set_algo.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/set_algo.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -32,8 +32,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_union(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
+ elements_begin(left), elements_end(left),
+ elements_begin(right), elements_end(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -56,8 +56,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_union(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
+ elements_rbegin(left), elements_rend(left),
+ elements_rbegin(right), elements_rend(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -82,8 +82,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_difference(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
+ elements_begin(left), elements_end(left),
+ elements_begin(right), elements_end(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -106,8 +106,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_difference(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
+ elements_rbegin(left), elements_rend(left),
+ elements_rbegin(right), elements_rend(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -132,8 +132,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_intersection(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
+ elements_begin(left), elements_end(left),
+ elements_begin(right), elements_end(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -156,8 +156,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_intersection(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
+ elements_rbegin(left), elements_rend(left),
+ elements_rbegin(right), elements_rend(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -182,8 +182,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_symmetric_difference(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
+ elements_begin(left), elements_end(left),
+ elements_begin(right), elements_end(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
@@ -206,8 +206,8 @@
void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_symmetric_difference(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
+ elements_rbegin(left), elements_rend(left),
+ elements_rbegin(right), elements_rend(right),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
);
}
Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -50,15 +50,15 @@
map_a += make_pair(interval<int>::rightopen(0,3),1);
cout << map_a << endl;
- for(interval_map<int,int>::element_iterator elem = map_a.elements_begin();
- elem != map_a.elements_end(); elem++)
+ for(interval_map<int,int>::element_iterator elem = elements_begin(map_a);
+ elem != elements_end(map_a); elem++)
cout << "(" << elem->first << "," << elem->second << ")";
cout << "\n-------------------------------------\n";
std::pair<const int, int> search_pair(2,1);
interval_map<int,int>::element_const_iterator found
- = std::find(map_a.elements_begin(), map_a.elements_end(), search_pair);
+ = std::find(elements_begin(map_a), elements_end(map_a), search_pair);
cout << "(" << found->first << "," << found->second << ")\n";
const_cast<int&>(found->second) = 2;
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 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -1279,26 +1279,26 @@
map_a.insert(IIv(1,3,1)).insert(IIv(6,7,2));
typename IntervalMapT::atomized_type ato_map_a;
- ReptatorT el_it = map_a.elements_begin();
+ ReptatorT el_it = elements_begin(map_a);
VectorT vec(5), cev(5);
vec[0]=sK_v(1,1);vec[1]=sK_v(2,1);vec[2]=sK_v(3,1);vec[3]=sK_v(6,2);vec[4]=sK_v(7,2);
cev[0]=sK_v(7,2);cev[1]=sK_v(6,2);cev[2]=sK_v(3,1);cev[3]=sK_v(2,1);cev[4]=sK_v(1,1);
VectorT dest;
- std::copy(map_a.elements_begin(), map_a.elements_end(), std::back_inserter(dest));
+ std::copy(elements_begin(map_a), elements_end(map_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( vec == dest, true );
dest.clear();
- std::copy(map_a.elements_rbegin(), map_a.elements_rend(), std::back_inserter(dest));
+ std::copy(elements_rbegin(map_a), elements_rend(map_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( cev == dest, true );
dest.clear();
- std::reverse_copy(map_a.elements_rbegin(), map_a.elements_rend(), std::back_inserter(dest));
+ std::reverse_copy(elements_rbegin(map_a), elements_rend(map_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( vec == dest, true );
dest.clear();
- std::reverse_copy(map_a.elements_begin(), map_a.elements_end(), std::back_inserter(dest));
+ std::reverse_copy(elements_begin(map_a), elements_end(map_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( cev == dest, true );
}
Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2010-09-14 05:17:47 EDT (Tue, 14 Sep 2010)
@@ -773,19 +773,19 @@
cev[0]=MK_v(7);cev[1]=MK_v(6);cev[2]=MK_v(3);cev[3]=MK_v(2);cev[4]=MK_v(1);
VectorT dest;
- std::copy(set_a.elements_begin(), set_a.elements_end(), std::back_inserter(dest));
+ std::copy(elements_begin(set_a), elements_end(set_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( vec == dest, true );
dest.clear();
- std::copy(set_a.elements_rbegin(), set_a.elements_rend(), std::back_inserter(dest));
+ std::copy(elements_rbegin(set_a), elements_rend(set_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( cev == dest, true );
dest.clear();
- std::reverse_copy(set_a.elements_begin(), set_a.elements_end(), std::back_inserter(dest));
+ std::reverse_copy(elements_begin(set_a), elements_end(set_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( cev == dest, true );
dest.clear();
- std::reverse_copy(set_a.elements_rbegin(), set_a.elements_rend(), std::back_inserter(dest));
+ std::reverse_copy(elements_rbegin(set_a), elements_rend(set_a), std::back_inserter(dest));
BOOST_CHECK_EQUAL( vec == dest, true );
}
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