Subject: [Boost-commit] svn:boost r50343 - in sandbox/itl: boost/itl libs/itl/test
From: afojgo_at_[hidden]
Date: 2008-12-21 08:48:57
Author: jofaber
Date: 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
New Revision: 50343
URL: http://svn.boost.org/trac/boost/changeset/50343
Log:
Refactored: For Sets: 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 | 23 -
sandbox/itl/boost/itl/interval_base_set.hpp | 64 ++--
sandbox/itl/boost/itl/interval_map.hpp | 2
sandbox/itl/boost/itl/interval_maps.hpp | 53 +---
sandbox/itl/boost/itl/interval_set.hpp | 51 ++--
sandbox/itl/boost/itl/interval_sets.hpp | 453 ++++++++++++++-------------------------
sandbox/itl/boost/itl/separate_interval_set.hpp | 38 +-
sandbox/itl/boost/itl/split_interval_map.hpp | 2
sandbox/itl/boost/itl/split_interval_set.hpp | 52 ++--
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 63 +++--
10 files changed, 328 insertions(+), 473 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 08:48:55 EST (Sun, 21 Dec 2008)
@@ -223,7 +223,7 @@
// Corresponding abstract interval set type
- //typedef interval_base_set<SetSubType,DomainT,Interval,Compare,Alloc> interval_base_set_type;
+ //typedef interval_base_set<SetSubType,DomainT,Compare,Interval,Alloc> interval_base_set_type;
/// The atomized type is elementbased map that is equivalent to the interval map
typedef typename itl::map<DomainT,CodomainT,
@@ -551,9 +551,9 @@
All values within the scope of the interval set \c x will be erased.
*/
template<class SetSubType>
- SubType& erase(const interval_base_set<SetSubType,DomainT,Interval,Compare,Alloc>& x)
+ SubType& erase(const interval_base_set<SetSubType,DomainT,Compare,Interval,Alloc>& x)
{
- typedef interval_base_set<SetSubType,DomainT,Interval,Compare,Alloc> interval_base_set_type;
+ typedef interval_base_set<SetSubType,DomainT,Compare,Interval,Alloc> interval_base_set_type;
for(typename interval_base_set_type::const_iterator x_ = x.begin(); x_ != x.end(); ++x_)
erase(*x_);
@@ -626,20 +626,16 @@
template
<
template
- <
- class DomT,
- template<class DomT2, ITL_COMPARE>class Interv,
- ITL_COMPARE Comp, ITL_ALLOC Allc
- >
+ <class DomT, ITL_COMPARE Comp, template<class DomT2, ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
void add_intersection
(
interval_base_map& section,
- const IntervalSet<DomainT,Interval,Compare,Alloc>& sectant
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& sectant
)const
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> set_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> set_type;
if(sectant.empty()) return;
// THINK JODO optimize using the ordering: if intervalls are beyond borders we can terminate
@@ -716,13 +712,10 @@
template
<
template
- <
- class DomT, template<class DomT2,ITL_COMPARE>class Interv,
- ITL_COMPARE Comp, ITL_ALLOC Allc
- >
+ <class DomT, ITL_COMPARE Comp, template<class DomT2, ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
- void domain(IntervalSet<DomainT,Interval,Compare,Alloc>& dom)const
+ void domain(IntervalSet<DomainT,Compare,Interval,Alloc>& dom)const
{
dom.clear();
const_FOR_IMPLMAP(it)
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
@@ -102,8 +102,8 @@
<
typename SubType,
typename DomainT,
- template<class, ITL_COMPARE>class Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
+ template<class, ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
#ifdef USE_CONCEPTS
@@ -114,7 +114,7 @@
public:
//A: Type definitions for the template class
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> type;
/// The designated \e derived or \e sub_type of this base class
typedef SubType sub_type;
@@ -436,11 +436,11 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-typename interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::size_type
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::cardinality()const
+typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::size_type
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::cardinality()const
{
using namespace boost::mpl;
return if_<
@@ -467,12 +467,12 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
typename
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::difference_type
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::length()const
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::difference_type
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::length()const
{
difference_type length = neutron<difference_type>::value();
const_FOR_IMPL(it)
@@ -483,10 +483,10 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-bool interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+bool interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::contained_in(const interval_base_set& x2)const
{
// The empty set is subset of every set
@@ -510,8 +510,8 @@
template<class SubType,
- class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::add_intersection(interval_base_set& section, const value_type& x)const
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::add_intersection(interval_base_set& section, const value_type& x)const
{
// any intersection with the empty intervall is empty
if(x.empty())
@@ -530,8 +530,8 @@
template<class SubType,
- class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::join()
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::join()
{
iterator it=_set.begin();
if(it==_set.end())
@@ -573,8 +573,8 @@
template<class SubType,
- class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::uniform_bounds(typename interval<DomainT>::bound_types bt)
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::uniform_bounds(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
@@ -583,9 +583,9 @@
template<class SubType,
- class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-inline bool operator == (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+inline bool operator == (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{
//MEMO PORT: This implemetation worked with stlport, sgi and gnu
// implementations of the stl. But using MSVC-implementation
@@ -596,9 +596,9 @@
}
template<class SubType,
- class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-inline bool operator < (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+inline bool operator < (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{
return std::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
@@ -607,22 +607,22 @@
}
template<class SubType,
- class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-inline bool operator <= (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& lhs,
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+inline bool operator <= (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{
return lhs < rhs || lhs == rhs;
}
template<class CharType, class CharTraits,
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc>
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object)
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> IntervalSetT;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> IntervalSetT;
stream << "{";
const_FORALL(typename IntervalSetT, it, object)
stream << (*it);
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 08:48:55 EST (Sun, 21 Dec 2008)
@@ -137,7 +137,7 @@
typedef typename base_type::codomain_combine codomain_combine;
- typedef interval_set<DomainT,Interval,Compare,Alloc> interval_set_type;
+ typedef interval_set<DomainT,Compare,Interval,Alloc> interval_set_type;
typedef interval_set_type set_type;
/// Default constructor for the empty map
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 08:48:55 EST (Sun, 21 Dec 2008)
@@ -472,21 +472,16 @@
<
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,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
operator -=
(
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const IntervalSet<DomainT,Interval,Compare,Alloc>& erasure
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& erasure
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> set_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> set_type;
const_FORALL(typename set_type, interval_, erasure)
object.erase(*interval_);
@@ -497,18 +492,13 @@
<
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,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
operator -
(
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
@@ -786,26 +776,19 @@
template
<
class SubType, class DomainT, class CodomainT, class Traits,
-
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
//JODO boost::enable_if
bool is_disjoint
(
interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc> object_type;
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> operand_type;
object_type intersection;
if(operand.empty())
@@ -839,24 +822,19 @@
ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
//JODO boost::enable_if
bool is_disjoint
(
const IntervalMap<DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc> object_type;
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> operand_type;
object_type intersection;
if(operand.empty())
@@ -889,17 +867,12 @@
ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
>
class IntervalMap,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
//JODO boost::enable_if
bool is_disjoint
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& left,
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& left,
const IntervalMap<DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>& right
)
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
@@ -103,22 +103,21 @@
template
<
typename DomainT,
- template<class,ITL_COMPARE>class
- Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
class interval_set:
- public interval_base_set<interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc>
+ public interval_base_set<interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>
{
public:
/// The base_type of this class
- typedef interval_base_set<itl::interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc> base_type;
+ typedef interval_base_set<itl::interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc> base_type;
- typedef interval_set<DomainT,Interval,Compare,Alloc> type;
+ typedef interval_set<DomainT,Compare,Interval,Alloc> type;
typedef type joint_type;
/// The domain type of the set
@@ -175,7 +174,7 @@
/// Copy constructor for base_type
template<class SubType>
explicit interval_set
- (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{ assign(src); }
/// Constructor for a single element
@@ -188,15 +187,15 @@
/// Assignment operator
template<class SubType>
interval_set& operator =
- (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{ assign(src); return *this; }
/// Assignment from a base interval_set.
template<class SubType>
- void assign(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> base_set_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> base_set_type;
this->clear();
// Has to be implemented via add. there might be touching borders to be joined
const_FORALL(typename base_set_type, it, src)
@@ -205,8 +204,8 @@
private:
friend class
- interval_base_set<interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc>;
+ interval_base_set<interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>;
/// Does the set contain the interval <tt>x</tt>?
bool contains_(const interval_type& x)const;
@@ -227,8 +226,8 @@
-template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-bool interval_set<DomainT,Interval,Compare,Alloc>::contains_(const interval_type& x)const
+template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_set<DomainT,Compare,Interval,Alloc>::contains_(const interval_type& x)const
{
// Emptiness is contained in everything
if(x.empty())
@@ -249,8 +248,8 @@
}
-template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void interval_set<DomainT,Interval,Compare,Alloc>::handle_neighbours(const iterator& it)
+template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_set<DomainT,Compare,Interval,Alloc>::handle_neighbours(const iterator& it)
{
if(it == this->_set.begin())
{
@@ -290,9 +289,9 @@
-template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-typename interval_set<DomainT,Interval,Compare,Alloc>::iterator
- interval_set<DomainT,Interval,Compare,Alloc>
+template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_set<DomainT,Compare,Interval,Alloc>::iterator
+ interval_set<DomainT,Compare,Interval,Alloc>
::joint_insert(const iterator& left_it, const iterator& right_it)
{
// both left and right are in the set and they are neighbours
@@ -311,8 +310,8 @@
}
-template<class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void interval_set<DomainT,Interval,Compare,Alloc>::add_(const value_type& x)
+template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& x)
{
if(x.empty()) return;
@@ -344,8 +343,8 @@
}
-template<class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void interval_set<DomainT,Interval,Compare,Alloc>::subtract_(const value_type& x)
+template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& x)
{
if(x.empty()) return;
typename ImplSetT::iterator fst_it = this->_set.lower_bound(x);
@@ -372,8 +371,8 @@
//-----------------------------------------------------------------------------
template <typename DomainT, template<class,ITL_COMPARE>class Interval,
ITL_COMPARE Compare, ITL_ALLOC Alloc>
-inline bool is_element_equal(const interval_set<DomainT,Interval,Compare,Alloc>& lhs,
- const interval_set<DomainT,Interval,Compare,Alloc>& rhs)
+inline bool is_element_equal(const interval_set<DomainT,Compare,Interval,Alloc>& lhs,
+ const interval_set<DomainT,Compare,Interval,Alloc>& rhs)
{
return &lhs == &rhs || Set::lexicographical_equal(lhs, rhs);
}
Modified: sandbox/itl/boost/itl/interval_sets.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_sets.hpp (original)
+++ sandbox/itl/boost/itl/interval_sets.hpp 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
@@ -14,7 +14,7 @@
namespace boost{namespace itl
{
-template<typename, template<class,ITL_COMPARE>class, ITL_COMPARE, ITL_ALLOC>
+template<typename, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>
class interval_set;
//-----------------------------------------------------------------------------
@@ -22,23 +22,18 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>&
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
operator +=
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> set_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> set_type;
const_FORALL(typename set_type, elem_, operand)
object.add(*elem_);
@@ -47,23 +42,18 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
operator +
(
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
@@ -71,20 +61,15 @@
//--- interval_type -----------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>&
+IntervalSet<DomainT,Compare,Interval,Alloc>&
operator +=
(
- IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& interval
+ IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& interval
)
{
return object.add(interval);
@@ -92,23 +77,18 @@
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>
+IntervalSet<DomainT,Compare,Interval,Alloc>
operator +
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
@@ -116,20 +96,15 @@
//--- domain_type -------------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>&
+IntervalSet<DomainT,Compare,Interval,Alloc>&
operator +=
(
- IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::domain_type& value
+ IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::domain_type& value
)
{
return object.add(value);
@@ -137,23 +112,18 @@
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>
+IntervalSet<DomainT,Compare,Interval,Alloc>
operator +
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::domain_type& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::domain_type& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) += operand;
}
//-----------------------------------------------------------------------------
@@ -163,23 +133,18 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>&
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
operator -=
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> operand_type;
const_FORALL(typename operand_type, elem_, operand)
object.subtract(*elem_);
@@ -188,23 +153,18 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
operator -
(
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -213,20 +173,15 @@
//--- interval_type -----------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>&
+IntervalSet<DomainT,Compare,Interval,Alloc>&
operator -=
(
- IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& interval
+ IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& interval
)
{
return object.subtract(interval);
@@ -234,23 +189,18 @@
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>
+IntervalSet<DomainT,Compare,Interval,Alloc>
operator -
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -258,20 +208,15 @@
//--- domain_type -------------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>&
+IntervalSet<DomainT,Compare,Interval,Alloc>&
operator -=
(
- IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::domain_type& value
+ IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::domain_type& value
)
{
return object.subtract(value);
@@ -279,23 +224,18 @@
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>
+IntervalSet<DomainT,Compare,Interval,Alloc>
operator -
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::domain_type& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::domain_type& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) -= operand;
}
//-----------------------------------------------------------------------------
@@ -305,24 +245,19 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>&
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
operator *=
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> object_type;
- typedef IntervalSet <DomainT,Interval,Compare,Alloc> operand_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> object_type;
+ typedef IntervalSet <DomainT,Compare,Interval,Alloc> operand_type;
object_type intersection;
if(operand.empty())
@@ -351,23 +286,18 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
operator *
(
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) *= operand;
}
//-----------------------------------------------------------------------------
@@ -375,23 +305,18 @@
//--- interval_type -----------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>&
+IntervalSet<DomainT,Compare,Interval,Alloc>&
operator *=
(
- IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& interval
+ IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& interval
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> object_type;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> object_type;
object_type intersection;
if(interval.empty())
@@ -407,23 +332,18 @@
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>
+IntervalSet<DomainT,Compare,Interval,Alloc>
operator *
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
- const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& operand
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
+ const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) *= operand;
}
//-----------------------------------------------------------------------------
@@ -431,46 +351,36 @@
//--- domain_type -------------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>&
+IntervalSet<DomainT,Compare,Interval,Alloc>&
operator *=
(
- IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const DomainT& value
)
{
- typedef typename IntervalSet<DomainT,Interval,Compare,Alloc>
+ typedef typename IntervalSet<DomainT,Compare,Interval,Alloc>
::interval_type interval_type;
return object *= interval_type(value);
}
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-IntervalSet<DomainT,Interval,Compare,Alloc>
+IntervalSet<DomainT,Compare,Interval,Alloc>
operator *
(
- const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const DomainT& operand
)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
return ObjectT(object) *= operand;
}
//-----------------------------------------------------------------------------
@@ -480,19 +390,14 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
bool is_element_equal
(
- const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
return Interval_Set::is_element_equal(object, operand);
@@ -505,23 +410,18 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
bool is_disjoint
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> object_type;
- typedef IntervalSet <DomainT,Interval,Compare,Alloc> operand_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> object_type;
+ typedef IntervalSet <DomainT,Compare,Interval,Alloc> operand_type;
object_type intersection;
if(operand.empty())
@@ -544,28 +444,24 @@
return true;
}
+/*CL used??? if so move it to interval_maps.hpp
template
<
- class SubType, class DomainT, class CodomainT,
- class Traits, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, class, class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalMap
+ 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, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
bool is_disjoint
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
const IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Alloc>& operand
+ Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> object_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> object_type;
typedef IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Alloc> operand_type;
+ Traits,Compare,Interval,Alloc> operand_type;
object_type intersection;
if(operand.empty())
@@ -589,27 +485,22 @@
return true;
}
-
+*/
//-----------------------------------------------------------------------------
// insert
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>&
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
insert
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
return object += operand;
@@ -620,20 +511,15 @@
//-----------------------------------------------------------------------------
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-interval_base_set<SubType,DomainT,Interval,Compare,Alloc>&
+interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
erase
(
- interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
- const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+ interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
+ const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
return object -= operand;
@@ -645,19 +531,14 @@
//-----------------------------------------------------------------------------
template
<
- class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc,
- template
- <
- class, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC
- >
- class IntervalSet
+ class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
-typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type
-enclosure(const IntervalSet<DomainT,Interval,Compare,Alloc>& object)
+typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type
+enclosure(const IntervalSet<DomainT,Compare,Interval,Alloc>& object)
{
- typedef IntervalSet<DomainT,Interval,Compare,Alloc> IntervalSetT;
+ typedef IntervalSet<DomainT,Compare,Interval,Alloc> IntervalSetT;
typedef typename IntervalSetT::interval_type interval_type;
return
object.empty() ? neutron<interval_type>::value()
@@ -666,13 +547,13 @@
template
<
- class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
- ITL_COMPARE Compare, ITL_ALLOC Alloc
+ class SubType, class DomainT,
+ ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
-typename interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::interval_type
-enclosure(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object)
+typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::interval_type
+enclosure(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> IntervalSetT;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> IntervalSetT;
typedef typename IntervalSetT::interval_type interval_type;
return
object.empty() ? neutron<interval_type>::value()
Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
@@ -67,23 +67,23 @@
template
<
typename DomainT,
- template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
class separate_interval_set:
- public interval_base_set<separate_interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc>
+ public interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>
{
public:
// inherit all typedefs
- typedef interval_base_set<itl::separate_interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc> base_type;
+ typedef interval_base_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc> base_type;
- typedef separate_interval_set<DomainT,Interval,Compare,Alloc> type;
+ typedef separate_interval_set<DomainT,Compare,Interval,Alloc> type;
- typedef interval_set<DomainT,Interval,Compare,Alloc> joint_type;
+ typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
/// The domain type of the set
typedef DomainT domain_type;
@@ -140,7 +140,7 @@
/// Copy constructor for base_type
template<class SubType>
separate_interval_set
- (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{ assign(src); }
/// Constructor for a single element
@@ -151,14 +151,14 @@
/// Assignment operator
template<class SubType>
separate_interval_set& operator =
- (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{ assign(src); return *this; }
/// Assignment from a base interval_set.
template<class SubType>
- void assign(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> base_set_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> base_set_type;
this->clear();
// Can be implemented via _set.insert: Interval joining not necessary.
const_FORALL(typename base_set_type, it, src)
@@ -167,8 +167,8 @@
private:
friend class
- interval_base_set<separate_interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc>;
+ interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>;
/// Does the set contain the interval <tt>x</tt>?
bool contains_(const interval_type& x)const;
@@ -185,8 +185,8 @@
} ;
-template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-bool separate_interval_set<DomainT,Interval,Compare,Alloc>::contains_(const interval_type& interv)const
+template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool separate_interval_set<DomainT,Compare,Interval,Alloc>::contains_(const interval_type& interv)const
{
if(interv.empty())
return true;
@@ -197,8 +197,8 @@
}
-template<class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void separate_interval_set<DomainT,Interval,Compare,Alloc>::add_(const value_type& x)
+template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void separate_interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& x)
{
if(x.empty()) return;
@@ -230,8 +230,8 @@
}
-template<class DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-void separate_interval_set<DomainT,Interval,Compare,Alloc>::subtract_(const value_type& x)
+template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void separate_interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& x)
{
if(x.empty()) return;
typename ImplSetT::iterator fst_it = this->_set.lower_bound(x);
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 08:48:55 EST (Sun, 21 Dec 2008)
@@ -158,7 +158,7 @@
typedef typename base_type::codomain_combine codomain_combine;
- typedef interval_set<DomainT,Interval,Compare,Alloc> interval_set_type;
+ typedef interval_set<DomainT,Compare,Interval,Alloc> interval_set_type;
typedef interval_set_type set_type;
/// Default constructor for the empty map
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
@@ -88,20 +88,20 @@
template
<
typename DomainT,
- template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
class split_interval_set:
- public interval_base_set<split_interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc>
+ public interval_base_set<split_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>
{
public:
- typedef interval_base_set<itl::split_interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc> base_type;
+ typedef interval_base_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc> base_type;
- typedef split_interval_set<DomainT,Interval,Compare,Alloc> type;
- typedef interval_set<DomainT,Interval,Compare,Alloc> joint_type;
+ typedef split_interval_set<DomainT,Compare,Interval,Alloc> type;
+ typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
/// The domain type of the set
typedef DomainT domain_type;
@@ -157,7 +157,7 @@
/// Copy constructor for base_type
template<class SubType>
split_interval_set
- (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{ assign(src); }
/// Constructor for a single element
@@ -168,14 +168,14 @@
/// Assignment operator
template<class SubType>
split_interval_set& operator =
- (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{ assign(src); return *this; }
/// Assignment from a base interval_set.
template<class SubType>
- void assign(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& src)
+ void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> base_set_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> base_set_type;
this->clear();
// Can be implemented via _set.insert: Interval joining not necessary.
const_FORALL(typename base_set_type, it, src)
@@ -184,8 +184,8 @@
private:
friend class
- interval_base_set<split_interval_set<DomainT,Interval,Compare,Alloc>,
- DomainT,Interval,Compare,Alloc>;
+ interval_base_set<split_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>;
/// Does the set contain the interval <tt>x</tt>?
bool contains_(const interval_type& x)const;
@@ -204,8 +204,8 @@
void subtract_rest(const interval_type& x_itv, iterator& it, iterator& end_it);
} ;
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- bool split_interval_set<DomainT,Interval,Compare,Alloc>::contains_(const interval_type& interv)const
+ template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ bool split_interval_set<DomainT,Compare,Interval,Alloc>::contains_(const interval_type& interv)const
{
if(interv.empty())
return true;
@@ -216,8 +216,8 @@
}
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- void split_interval_set<DomainT,Interval,Compare,Alloc>::add_(const value_type& x)
+ template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ void split_interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& x)
{
if(x.empty()) return;
@@ -278,8 +278,8 @@
}
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- void split_interval_set<DomainT,Interval,Compare,Alloc>::insert_rest(const interval_type& x_itv, iterator& it, iterator& end_it)
+ template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ void split_interval_set<DomainT,Compare,Interval,Alloc>::insert_rest(const interval_type& x_itv, iterator& it, iterator& end_it)
{
iterator nxt_it = it; nxt_it++;
@@ -319,8 +319,8 @@
}
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- void split_interval_set<DomainT,Interval,Compare,Alloc>::subtract_(const value_type& x)
+ template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ void split_interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& x)
{
if(x.empty()) return;
if(this->_set.empty()) return;
@@ -370,8 +370,8 @@
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- void split_interval_set<DomainT,Interval,Compare,Alloc>::subtract_rest(const interval_type& x_itv, iterator& snd_it, iterator& end_it)
+ template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ void split_interval_set<DomainT,Compare,Interval,Alloc>::subtract_rest(const interval_type& x_itv, iterator& snd_it, iterator& end_it)
{
iterator it=snd_it, nxt_it=snd_it; nxt_it++;
@@ -405,9 +405,9 @@
NOTE: This is not inline with the mathematical view.
We have a distiction between 'element equality' and 'lexicographical
equality'. */
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- inline bool operator == (const split_interval_set<DomainT,Interval,Compare,Alloc>& lhs,
- const split_interval_set<DomainT,Interval,Compare,Alloc>& rhs)
+ template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ inline bool operator == (const split_interval_set<DomainT,Compare,Interval,Alloc>& lhs,
+ const split_interval_set<DomainT,Compare,Interval,Alloc>& rhs)
{
//MEMO PORT: This implemetation worked with stlport, sgi and gnu
// implementations of the stl. But using MSVC-implementation
Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2008-12-21 08:48:55 EST (Sun, 21 Dec 2008)
@@ -9,9 +9,10 @@
#define __test_itl_interval_set_shared_h_JOFA_080920__
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_fundamentals_4_ordered_types()
@@ -141,9 +142,10 @@
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_ctor_4_bicremental_types()
@@ -192,9 +194,10 @@
}
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_add_sub_4_bicremental_types()
@@ -234,9 +237,10 @@
}
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_distinct_4_bicremental_types()
@@ -260,9 +264,10 @@
}
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_distinct_4_bicremental_continuous_types()
@@ -301,9 +306,10 @@
}
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_isolate_4_bicremental_continuous_types()
@@ -345,9 +351,10 @@
}
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_contains_4_bicremental_types()
@@ -383,9 +390,10 @@
}
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_operators_4_bicremental_types()
@@ -426,9 +434,10 @@
// Test for nontrivial intersection of interval sets with intervals and values
-template <template<class T, template<class,ITL_COMPARE>class Interval = interval,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_ALLOC Alloc = std::allocator
+template <template< class T,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
+ template<class,ITL_COMPARE>class Interval = interval,
+ ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_base_intersect_4_bicremental_types()