Subject: [Boost-commit] svn:boost r50342 - in sandbox/itl: boost/itl libs/itl/example/boost_party libs/itl/test
From: afojgo_at_[hidden]
Date: 2008-12-21 06:38:13
Author: jofaber
Date: 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
New Revision: 50342
URL: http://svn.boost.org/trac/boost/changeset/50342
Log:
Refactored: For Maps: Added template parameter ITL_SECTION Section. Moved template parameter Interval before Alloc.
Stable {msvc-9.0, partly congcc-4.3-a7}
Text files modified:
sandbox/itl/boost/itl/interval_base_map.hpp | 165 ++++++------
sandbox/itl/boost/itl/interval_map.hpp | 119 ++++----
sandbox/itl/boost/itl/interval_maps.hpp | 519 ++++++++++++++++++++-------------------
sandbox/itl/boost/itl/map.hpp | 91 +++---
sandbox/itl/boost/itl/notate.hpp | 13 +
sandbox/itl/boost/itl/rational.hpp | 4
sandbox/itl/boost/itl/split_interval_map.hpp | 85 +++---
sandbox/itl/libs/itl/example/boost_party/boost_party.cpp | 2
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 33 +
9 files changed, 530 insertions(+), 501 deletions(-)
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 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -140,10 +140,10 @@
typename DomainT,
typename CodomainT,
class Traits = itl::neutron_absorber,
- template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- //ITL_SECTION Section= ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
#ifdef USE_CONCEPTS
@@ -160,11 +160,11 @@
typedef SubType sub_type;
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>
+ Traits,Compare,Combine,Section,Interval,Alloc>
type;
typedef interval_base_map<SubType,DomainT,CodomainT,
- itl::neutron_absorber,Interval,Compare,Combine,Alloc>
+ itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
neutron_absorber_type;
/// Domain type (type of the keys) of the map
@@ -188,6 +188,9 @@
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
/// Combine functor for codomain values
typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
+ /// Intersection functor for codomain values
+ typedef ITL_SECTION_CODOMAIN(Section,CodomainT) codomain_intersect;
+
/// Comparison functor for intervals which are keys as well
typedef exclusive_less<interval_type> interval_compare;
@@ -200,7 +203,7 @@
/// Container type for the implementation
typedef itl::map<interval_type,codomain_type,Traits,
- ITL_EXCLUSIVE_LESS(interval_type),Combine,Alloc> ImplMapT;
+ ITL_EXCLUSIVE_LESS(interval_type),Combine,Section,Alloc> ImplMapT;
/// key type of the implementing container
typedef typename ImplMapT::key_type key_type;
@@ -224,7 +227,7 @@
/// The atomized type is elementbased map that is equivalent to the interval map
typedef typename itl::map<DomainT,CodomainT,
- Traits,Compare,Combine,Alloc> atomized_type;
+ Traits,Compare,Combine,Section,Alloc> atomized_type;
//@}
public:
@@ -653,16 +656,16 @@
<
template
<
- class DomT, class CodomT,
- class Trts, template<class DomT2,ITL_COMPARE>class Interv,
- ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_ALLOC Allc
+ class DomT, class CodomT, class Trts,
+ ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect,
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc
>
class IntervalMap
>
void add_intersection
(
interval_base_map& intersection,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& sectant
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& sectant
)const;
//@}
@@ -856,13 +859,13 @@
template
<
class SubType, class DomainT, class CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare,
- ITL_COMBINE Combine, ITL_ALLOC Alloc
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
+ template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
typename interval_base_map<SubType,DomainT,CodomainT,Traits,
- Interval,Compare,Combine,Alloc>::size_type
+ Compare,Combine,Section,Interval,Alloc>::size_type
interval_base_map<SubType,DomainT,CodomainT,Traits,
- Interval,Compare,Combine,Alloc>::cardinality()const
+ Compare,Combine,Section,Interval,Alloc>::cardinality()const
{
using namespace boost::mpl;
return if_<
@@ -876,13 +879,13 @@
template
<
class SubType, class DomainT, class CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare,
- ITL_COMBINE Combine, ITL_ALLOC Alloc
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
+ template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
typename interval_base_map<SubType,DomainT,CodomainT,Traits,
- Interval,Compare,Combine,Alloc>::difference_type
+ Compare,Combine,Section,Interval,Alloc>::difference_type
interval_base_map<SubType,DomainT,CodomainT,Traits,
- Interval,Compare,Combine,Alloc>::length()const
+ Compare,Combine,Section,Interval,Alloc>::length()const
{
difference_type length = neutron<difference_type>::value();
const_FOR_IMPLMAP(it)
@@ -896,9 +899,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-bool interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::contained_in(const interval_base_map& super)const
+bool interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::contained_in(const interval_base_map& super)const
{
// x2 should be larger than *this; so every element in this should be in x2
const_FOR_IMPLMAP(it)
@@ -911,29 +914,29 @@
template
<
class SubType,
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
+ template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
template
<
template
<
- class DomT, class CodomT,
- class Trts, template<class DomT2,ITL_COMPARE>class Interv,
- ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_ALLOC Allc
+ class DomT, class CodomT, class Trts,
+ ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect,
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc
>
class IntervalMap
>
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_intersection
(
interval_base_map& intersection,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& sectant
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& sectant
)const
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> sectant_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> sectant_type;
if(sectant.empty())
return;
typename sectant_type::const_iterator common_lwb;
@@ -948,11 +951,11 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_intersection(interval_base_map& section,
- const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::value_type& sectant)const
{
interval_type sectant_interval = sectant.KEY_VALUE;
@@ -981,11 +984,11 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_intersection(interval_base_map& section,
- const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::interval_type& sectant_interval)const
{
if(sectant_interval.empty()) return;
@@ -1008,9 +1011,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join()
{
iterator it=_map.begin();
@@ -1057,9 +1060,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-std::string interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::as_string()const
+std::string interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::as_string()const
{
std::string res("");
const_FOR_IMPLMAP(it) {
@@ -1077,9 +1080,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-CodomainT interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::sum()const
+CodomainT interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::sum()const
{
CodomainT sum = CodomainT();
const_FOR_IMPLMAP(it)
@@ -1091,9 +1094,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::uniformBounds( typename interval<DomainT>::bound_types bt)
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::uniformBounds( typename interval<DomainT>::bound_types bt)
{
// I can do this only, because I am shure that the contents and the
// ordering < on interval is invariant wrt. this transformation on bounds
@@ -1103,9 +1106,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::closeLeftBounds()
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::closeLeftBounds()
{
// I can do this only, because I am shure that the contents and the
// ordering < on interval is invariant wrt. this transformation on bounds
@@ -1117,9 +1120,9 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase(const interval_type& x_itv)
{
if(x_itv.empty()) return *that();
@@ -1155,10 +1158,10 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
SubType&
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+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)
@@ -1179,10 +1182,10 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+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)
{
//MEMO PORT: This implemetation worked with stlport, sgi and gnu
// implementations of the stl. But using MSVC-implementation
@@ -1195,13 +1198,13 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+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)
{
- interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> lhs0 = lhs;
- interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> rhs0 = rhs;
+ interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> lhs0 = lhs;
+ interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> rhs0 = rhs;
lhs0.absorb_neutrons();
rhs0.absorb_neutrons();
@@ -1216,10 +1219,10 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-inline bool operator < (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+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(),
@@ -1230,10 +1233,10 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-inline bool operator <= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+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 || lhs == rhs;
}
@@ -1244,22 +1247,22 @@
template
<
class SubType,
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
+ template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>&
+ Traits,Compare,Combine,Section,Interval,Alloc>&
min_assign
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& operand
+ Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> map_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> map_type;
const_FORALL(typename map_type, elem_, operand)
object.template add<inplace_min >(*elem_);
@@ -1269,22 +1272,22 @@
template
<
class SubType,
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
+ template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>&
+ Traits,Compare,Combine,Section,Interval,Alloc>&
max_assign
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& operand
+ Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> map_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> map_type;
const_FORALL(typename map_type, elem_, operand)
object.template add<inplace_max>(*elem_);
@@ -1295,15 +1298,15 @@
template<class CharType, class CharTraits,
class SubType, class DomainT, class CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare,
- ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
+ template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
const interval_base_map<SubType,DomainT,CodomainT,Traits,
- Interval,Compare,Combine,Alloc>& object)
+ Compare,Combine,Section,Interval,Alloc>& object)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> IntervalMapT;
+ Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
stream << "{";
const_FORALL(typename IntervalMapT, it, object)
stream << "(" << (*it).KEY_VALUE << "->" << (*it).CONT_VALUE << ")";
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -107,24 +107,25 @@
typename DomainT,
typename CodomainT,
class Traits = itl::neutron_absorber,
- template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
class interval_map:
- public interval_base_map<interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>,
- DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ public interval_base_map<interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
{
public:
typedef Traits traits;
- typedef interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> type;
+ typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
typedef type joint_type;
- typedef interval_base_map <interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>,
- DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> base_type;
+ typedef interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
- typedef interval_map<DomainT,CodomainT,itl::neutron_absorber,Interval,Compare,Combine,Alloc>
+ typedef interval_map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
neutron_absorber_type;
typedef Interval<DomainT,Compare> interval_type;
@@ -149,7 +150,7 @@
template<class SubType>
explicit interval_map
(const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& src)
+ Traits,Compare,Combine,Section,Interval,Alloc>& src)
{ assign(src); }
explicit interval_map(mapping_pair_type& base_pair): base_type()
@@ -162,16 +163,16 @@
template<class SubType>
interval_map& operator =
(const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& src)
+ Traits,Compare,Combine,Section,Interval,Alloc>& src)
{ assign(src); return *this; }
/// Assignment from a base interval_map.
template<class SubType>
void assign(const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& src)
+ Traits,Compare,Combine,Section,Interval,Alloc>& src)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> base_map_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
this->clear();
// Can be implemented via _map.insert: Interval joining not necessary.
const_FORALL(typename base_map_type, it, src)
@@ -185,8 +186,8 @@
// that()->funx_. So they must be either public or made accessible by a
// friend declaration:
friend class
- interval_base_map <interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>,
- DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>;
+ interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>;
bool contains_(const value_type& x)const;
@@ -242,8 +243,8 @@
} ;
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::contains_(const value_type& interv_value)const
{
interval_type interv = interv_value.KEY_VALUE;
@@ -257,8 +258,8 @@
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::joinable(const iterator& some, const iterator& next)const
{
// assert: next != end && some++ == next
@@ -267,9 +268,9 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
- interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+ interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::joint_insert(iterator& left_it, const iterator& right_it)
{
// both left and right are in the set and they are neighbours
@@ -297,8 +298,8 @@
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join_left(iterator& it)
{
if(it == this->_map.begin())
@@ -319,8 +320,8 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join_right(iterator& it)
{
if(it == this->_map.end())
@@ -341,9 +342,9 @@
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::fill_join_left(const value_type& value)
{
//collision free insert is asserted
@@ -360,9 +361,9 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::fill_join_both(const value_type& value)
{
//collision free insert is asserted
@@ -380,10 +381,10 @@
//-----------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::fill_gap_join_left(const value_type& value)
{
//collision free insert is asserted
@@ -411,10 +412,10 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::fill_gap_join_both(const value_type& value)
{
//collision free insert is asserted
@@ -445,9 +446,9 @@
//-----------------------------------------------------------------------------
// add<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -547,9 +548,9 @@
}
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it)
{
iterator nxt_it = it; nxt_it++;
@@ -580,9 +581,9 @@
add_rear<Combiner>(x_rest, x_val, it);
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_rear(const interval_type& x_rest, const CodomainT& x_val, iterator& it)
{
interval_type cur_itv = (*it).KEY_VALUE ;
@@ -622,9 +623,9 @@
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -691,9 +692,9 @@
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it)
{
iterator nxt_it=it; nxt_it++;
@@ -762,9 +763,9 @@
//-----------------------------------------------------------------------------
// insert(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -827,9 +828,9 @@
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_rest(const interval_type& x_itv, const CodomainT& x_val,
iterator& it, iterator& end_it)
{
@@ -855,9 +856,9 @@
insert_rear(x_rest, x_val, it);
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_rear(const interval_type& x_rest, const CodomainT& x_val,
iterator& it)
{
@@ -886,8 +887,8 @@
//-----------------------------------------------------------------------------
// erase(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -945,8 +946,8 @@
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_rest(const interval_type& x_itv, const CodomainT& x_val,
iterator& it, iterator& end_it)
{
Modified: sandbox/itl/boost/itl/interval_maps.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_maps.hpp (original)
+++ sandbox/itl/boost/itl/interval_maps.hpp 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -16,8 +16,8 @@
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class interval_map;
@@ -25,27 +25,53 @@
//-----------------------------------------------------------------------------
// addition +=
//-----------------------------------------------------------------------------
+/*CL
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator +=
(
- interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
+ const_FORALL(typename operand_type, elem_, operand)
+ object.add(*elem_);
+
+ return object;
+}
+*/
+template
+<
+ class ObjectT,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+ObjectT& operator +=
+(
+ ObjectT& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> operand_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
const_FORALL(typename operand_type, elem_, operand)
object.add(*elem_);
@@ -54,49 +80,47 @@
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator +
(
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
- typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator +=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> operand_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
const_FORALL(typename operand_type, elem_, operand)
object.add(*elem_);
@@ -105,24 +129,24 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator +
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
@@ -130,22 +154,22 @@
//--- value_type --------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator +=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const typename
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
)
{
return object.add(operand);
@@ -153,24 +177,24 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator +
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
@@ -192,21 +216,21 @@
*/
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator +=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
)
{
return object.add(operand);
@@ -214,24 +238,24 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator +
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
@@ -241,25 +265,25 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
- interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> operand_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
const_FORALL(typename operand_type, elem_, operand)
object.subtract(*elem_);
@@ -268,49 +292,47 @@
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
- typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> operand_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
const_FORALL(typename operand_type, elem_, operand)
object.subtract(*elem_);
@@ -319,24 +341,23 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -356,21 +377,20 @@
*/
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
)
{
return object.subtract(operand);
@@ -378,24 +398,23 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -404,21 +423,20 @@
//--- mapping_type ---------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
)
{
return object.subtract(operand);
@@ -426,24 +444,23 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -453,9 +470,8 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
class, template<class,ITL_COMPARE>class,
@@ -463,10 +479,10 @@
>
class IntervalSet
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
- interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalSet<DomainT,Interval,Compare,Alloc>& erasure
)
{
@@ -479,9 +495,8 @@
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
class, template<class,ITL_COMPARE>class,
@@ -489,14 +504,14 @@
>
class IntervalSet
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
)
{
- typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -504,21 +519,20 @@
//--- value_type --------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type& operand
)
{
return object.erase(operand);
@@ -526,24 +540,23 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -554,16 +567,15 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
class OperandT
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
insert
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const OperandT& operand
)
{
@@ -577,16 +589,15 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
class OperandT
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
erase
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const OperandT& operand
)
{
@@ -600,21 +611,20 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
class SectanT
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator *=
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const SectanT& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> object_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
object_type intersection;
object.add_intersection(intersection,operand);
object.swap(intersection);
@@ -623,44 +633,42 @@
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
class SectanT
>
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator *
(
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const SectanT& operand
)
{
- typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) *= operand;
}
//-----------------------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator *=
(
- IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> object_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
object_type intersection;
object.add_intersection(intersection,operand);
object.swap(intersection);
@@ -669,24 +677,23 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator *
(
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
return ObjectT(object) *= operand;
}
//-----------------------------------------------------------------------------
@@ -696,28 +703,27 @@
//-----------------------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class LeftIntervalMap,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class RightIntervalMap
>
bool is_element_equal
(
const LeftIntervalMap <DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& left,
+ Traits,Compare,Combine,Section,Interval,Alloc>& left,
const RightIntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& right
+ Traits,Compare,Combine,Section,Interval,Alloc>& right
)
{
return Interval_Set::is_element_equal(left, right);
@@ -731,13 +737,12 @@
//--- IntervalMap -------------------------------------------------------------
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
@@ -745,15 +750,15 @@
bool is_disjoint
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& operand
+ Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> object_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> operand_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
object_type intersection;
if(operand.empty())
@@ -780,8 +785,8 @@
/*CL
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
+ class SubType, class DomainT, class CodomainT, class Traits,
+
ITL_COMPARE Compare, ITL_ALLOC Alloc,
template
<
@@ -794,12 +799,12 @@
bool is_disjoint
(
interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> object_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
object_type intersection;
@@ -826,13 +831,12 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap,
template
@@ -846,12 +850,12 @@
bool is_disjoint
(
const IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> object_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
object_type intersection;
@@ -877,13 +881,12 @@
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap,
template
@@ -898,7 +901,7 @@
(
const IntervalSet<DomainT,Interval,Compare,Alloc>& left,
const IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& right
+ Traits,Compare,Combine,Section,Interval,Alloc>& right
)
{
return is_disjoint(right, left);
@@ -909,20 +912,19 @@
//-----------------------------------------------------------------------------
template
<
- class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
<
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap
>
-typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type
-enclosure(const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object)
+typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type
+enclosure(const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object)
{
- typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> IntervalMapT;
+ typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
typedef typename IntervalMapT::interval_type interval_type;
return
object.empty() ? neutron<interval_type>::value()
@@ -932,14 +934,13 @@
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+ class SubType, class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-typename interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type
-enclosure(const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object)
+typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type
+enclosure(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object)
{
- typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> IntervalMapT;
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
typedef typename IntervalMapT::interval_type interval_type;
return
object.empty() ? neutron<interval_type>::value()
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -105,6 +105,7 @@
class Traits = itl::neutron_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT),
ITL_ALLOC Alloc = std::allocator
>
class map: private std::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
@@ -113,12 +114,12 @@
public:
typedef Alloc<typename std::pair<const DomainT, CodomainT> > allocator_type;
- typedef typename itl::map<DomainT,CodomainT,Traits, Compare,Combine,Alloc> type;
+ typedef typename itl::map<DomainT,CodomainT,Traits, Compare,Combine,Section,Alloc> type;
typedef typename std::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
allocator_type> base_type;
typedef typename itl::set<DomainT, Compare, Alloc > set_type;
- typedef itl::map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Alloc>
+ typedef itl::map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Alloc>
neutron_absorber_type;
typedef Traits traits;
@@ -316,60 +317,60 @@
/** Standard equality, which is lexicographical equality of the sets
as sequences, that are given by their Compare order. */
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- inline bool operator == (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ inline bool operator == (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+ const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
{
typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
return operator==((const base_type&)lhs, (const base_type&)rhs);
}
//JODO comment...
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- inline bool is_element_equal(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ inline bool is_element_equal(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+ const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
{
typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
return operator==((const base_type&)lhs, (const base_type&)rhs);
}
/** Protonic equality is equality on all elements that do not carry a neutron as content. */
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- inline bool is_protonic_equal (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ inline bool is_protonic_equal (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+ const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
{
//JODO: Efficient implementation.
typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
- itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> lhs0 = lhs;
- itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> rhs0 = rhs;
+ itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> lhs0 = lhs;
+ itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> rhs0 = rhs;
lhs0.absorb_neutrons();
rhs0.absorb_neutrons();
return operator==((const base_type&)lhs0, (const base_type&)rhs0);
}
/** Strict weak less ordering which is given by the Compare order */
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- inline bool operator < (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ inline bool operator < (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+ const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
{
typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
return operator<((const base_type&)lhs, (const base_type&)rhs);
}
/** Partial ordering which is induced by Compare */
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- inline bool operator <= (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ inline bool operator <= (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+ const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
{
typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
return operator<=((const base_type&)lhs, (const base_type&)rhs);
}
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
template <class Combiner>
- typename map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::iterator
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::add(const value_type& val)
+ typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::add(const value_type& val)
{
if(Traits::absorbs_neutrons && val.CONT_VALUE == CodomainT())
return end();
@@ -401,9 +402,9 @@
}
}
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- typename map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::size_type
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::size_type
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
::erase(const value_type& value_pair)
{
if(Traits::absorbs_neutrons && value_pair.CONT_VALUE == CodomainT())
@@ -421,9 +422,9 @@
}
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- typename map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::iterator
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::subtract(const value_type& val)
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::subtract(const value_type& val)
{
if(Traits::emits_neutrons)
return add<inverse_data_combine>(val);
@@ -447,8 +448,8 @@
}
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- std::string map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::as_string()const
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ std::string map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::as_string()const
{
std::string repr;
const_FORALL_THIS(it) {
@@ -463,9 +464,9 @@
return repr;
}
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
template<class Predicate>
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
::erase_if(const Predicate& pred)
{
iterator it = begin();
@@ -477,10 +478,10 @@
}
- template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
template<class Predicate>
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>
- ::assign_if(const map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& src, const Predicate& pred)
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+ ::assign_if(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& src, const Predicate& pred)
{
clear();
const_iterator it = src.begin();
@@ -492,12 +493,12 @@
}
//-------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>&
- insert(map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& object,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& insertee)
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
+ insert(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+ const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& insertee)
{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> map_type;
+ typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
const_FORALL(typename map_type, elem_, insertee)
object.insert(*elem_);
@@ -506,12 +507,12 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>&
- erase(map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& object,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& erasee)
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
+ erase(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+ const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& erasee)
{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> map_type;
+ typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
const_FORALL(typename map_type, elem_, erasee)
object.erase(*elem_);
Modified: sandbox/itl/boost/itl/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/notate.hpp (original)
+++ sandbox/itl/boost/itl/notate.hpp 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -79,6 +79,7 @@
#define ITL_USE_COMPARE_TEMPLATE_TEMPLATE
#define ITL_USE_COMBINE_TEMPLATE_TEMPLATE
+#define ITL_USE_SECTION_TEMPLATE_TEMPLATE
//------------------------------------------------------------------------------
// template parameter Compare can not be a template type parameter as long as
@@ -109,6 +110,18 @@
#endif
//------------------------------------------------------------------------------
+// template parameter Section could be a template type parameter.
+#ifdef ITL_USE_SECTION_TEMPLATE_TEMPLATE
+# define ITL_SECTION template<class>class
+# define ITL_SECTION_CODOMAIN(itl_intersect, codomain_type) itl_intersect<codomain_type>
+# define ITL_SECTION_INSTANCE(section_instance,codomain_type) section_instance
+#else//ITL_USE_SECTION_TEMPLATE_TYPE
+# define ITL_SECTION class
+# define ITL_SECTION_CODOMAIN(itl_intersect, codomain_type) itl_intersect
+# define ITL_SECTION_INSTANCE(section_instance,codomain_type) section_instance<codomain_type>
+#endif
+
+//------------------------------------------------------------------------------
#define ITL_ALLOC template<class>class
#endif // __itl_NOTATE_H_JOFA_990119__
Modified: sandbox/itl/boost/itl/rational.hpp
==============================================================================
--- sandbox/itl/boost/itl/rational.hpp (original)
+++ sandbox/itl/boost/itl/rational.hpp 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -7,9 +7,7 @@
+----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------
-itl_ptime provides adapter code for boost::posix_time::ptime.
-It implements incrementation (++) decrementation (--) and a neutral element
-w.r.t. addition (neutron()).
+itl_rational provides adapter code for boost::rational.
-----------------------------------------------------------------------------*/
#ifndef __itl_rational_JOFA_080913_H__
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 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -129,23 +129,24 @@
typename DomainT,
typename CodomainT,
class Traits = itl::neutron_absorber,
- template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
class split_interval_map:
- public interval_base_map<split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>,
- DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ public interval_base_map<split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
{
public:
typedef Traits traits;
- typedef split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> type;
- typedef interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> joint_type;
- typedef interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>,
- DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> base_type;
+ typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
+ typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> joint_type;
+ typedef interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
- typedef split_interval_map<DomainT,CodomainT,itl::neutron_absorber,Interval,Compare,Combine,Alloc>
+ typedef split_interval_map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
neutron_absorber_type;
typedef Interval<DomainT,Compare> interval_type;
@@ -175,16 +176,16 @@
template<class SubType>
split_interval_map& operator =
(const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& src)
+ Traits,Compare,Combine,Section,Interval,Alloc>& src)
{ assign(src); return *this; }
/// Assignment from a base interval_map.
template<class SubType>
void assign(const interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& src)
+ Traits,Compare,Combine,Section,Interval,Alloc>& src)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc> base_map_type;
+ Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
this->clear();
// Can be implemented via _map.insert: Interval joining not necessary.
const_FORALL(typename base_map_type, it, src)
@@ -199,8 +200,8 @@
// friend declaration:
friend class
interval_base_map
- <split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>,
- DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc >;
+ <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc >;
bool contains_(const value_type& x)const;
@@ -240,8 +241,8 @@
} ;
- template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
- bool split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ bool split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::contains_(const value_type& interv_value)const
{
interval_type interv = interv_value.KEY_VALUE;
@@ -257,8 +258,8 @@
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::fill(const value_type& value)
{
//collision free insert is asserted
@@ -270,9 +271,9 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::fill_gap(const value_type& value)
{
//collision free insert is asserted
@@ -298,9 +299,9 @@
//-----------------------------------------------------------------------------
// add<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -387,9 +388,9 @@
}
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_rest(const interval_type& x_itv, const CodomainT& x_val,
iterator& it, iterator& end_it)
{
@@ -416,9 +417,9 @@
add_rear<Combiner>(x_rest, x_val, it);
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_rear(const interval_type& x_rest, const CodomainT& x_val, iterator& it)
{
interval_type cur_itv = (*it).KEY_VALUE ;
@@ -451,9 +452,9 @@
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -510,9 +511,9 @@
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_rest(const interval_type& x_itv, const CodomainT& x_val,
iterator& it, iterator& end_it)
{
@@ -562,9 +563,9 @@
//-----------------------------------------------------------------------------
// insert(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -619,9 +620,9 @@
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_rest(const interval_type& x_itv, const CodomainT& x_val,
iterator& it, iterator& end_it)
{
@@ -640,9 +641,9 @@
insert_rear(x_rest, x_val, it);
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_rear(const interval_type& x_rest, const CodomainT& x_val,
iterator& it)
{
@@ -664,8 +665,8 @@
//-----------------------------------------------------------------------------
// erase(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_(const value_type& x)
{
const interval_type& x_itv = x.KEY_VALUE;
@@ -723,8 +724,8 @@
}
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_rest(const interval_type& x_itv, const CodomainT& x_val,
iterator& it, iterator& end_it)
{
Modified: sandbox/itl/libs/itl/example/boost_party/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party/boost_party.cpp 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -68,7 +68,7 @@
typedef interval_map<ptime, GuestSetT> BoostPartyAttendenceHistoryT;
// A party's height shall be defined as the maximum height of all guests ;-)
-typedef interval_map<ptime, int, neutron_absorber, interval, less, inplace_max > BoostPartyHeightHistoryT;
+typedef interval_map<ptime, int, neutron_absorber, less, inplace_max > BoostPartyHeightHistoryT;
void boost_party()
{
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 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -12,9 +12,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -160,9 +161,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -222,9 +224,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -276,9 +279,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -308,9 +312,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -358,9 +363,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -410,9 +416,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -453,9 +460,10 @@
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -516,9 +524,10 @@
// Test for nontrivial intersection of interval maps with intervals and values
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -628,9 +637,10 @@
// Test for nontrivial erasure of interval maps with intervals and interval sets
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -744,9 +754,10 @@
// Test first_collision
template <template<class T, class U,
class Traits = neutron_absorber,
- template<class,ITL_COMPARE>class Interval = interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>