Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r49687 - in sandbox/itl: boost/itl libs/itl/test
From: afojgo_at_[hidden]
Date: 2008-11-11 14:32:27

Next message: nielsdekker_at_[hidden]: "[Boost-commit] svn:boost r49688 - trunk/status"
Previous message: eric_at_[hidden]: "[Boost-commit] svn:boost r49686 - in trunk/boost/proto: . detail transform"

Author: jofaber
Date: 2008-11-11 14:32:26 EST (Tue, 11 Nov 2008)
New Revision: 49687
URL: http://svn.boost.org/trac/boost/changeset/49687

Log:
Refactored itl::interval_container template template parameter Compare to template class parameter.
Compare transformation ends. Limitation in passing Compare to different value_types. Stable {msvc-9.0}
Text files modified:
   sandbox/itl/boost/itl/interval_base_map.hpp | 59 ++++++++++++++++++------------------
   sandbox/itl/boost/itl/interval_base_set.hpp | 30 +++++++++---------
   sandbox/itl/boost/itl/interval_map.hpp | 42 +++++++++++++-------------
   sandbox/itl/boost/itl/interval_maps.hpp | 28 ++++++++--------
   sandbox/itl/boost/itl/interval_set.hpp | 20 ++++++------
   sandbox/itl/boost/itl/interval_sets.hpp | 64 ++++++++++++++++++++--------------------
   sandbox/itl/boost/itl/separate_interval_set.hpp | 16 +++++-----
   sandbox/itl/boost/itl/split_interval_map.hpp | 30 +++++++++---------
   sandbox/itl/boost/itl/split_interval_set.hpp | 24 +++++++-------
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 22 ++++++------
   sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 18 +++++-----
   11 files changed, 177 insertions(+), 176 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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -136,7 +136,7 @@
     typename CodomainT,
     class Traits = itl::neutron_absorber,
     template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
     template<class>class Alloc = std::allocator
>
#ifdef USE_CONCEPTS
@@ -183,7 +183,7 @@
     typedef typename interval_type::size_type size_type;

     /// Comparison functor for domain values
- typedef Compare<DomainT> domain_compare;
+ typedef Compare domain_compare;
     /// Comparison functor for intervals which are keys as well
     typedef exclusive_less<interval_type> interval_compare;

@@ -220,7 +220,7 @@

     /// The atomized type is elementbased map that is equivalent to the interval map
     typedef typename itl::map<DomainT,CodomainT,
- Traits,Compare<DomainT>,Alloc> atomized_type;
+ Traits,Compare,Alloc> atomized_type;
//@}

public:
@@ -624,7 +624,7 @@
         template
         <
             class DomT, template<class>class Interv,
- template<class>class Comp, template<class>class Allc
+ class Comp, template<class>class Allc
>
         class IntervalSet
>
@@ -653,7 +653,7 @@
         <
             class DomT, class CodomT,
             class Trts, template<class>class Interv,
- template<class>class Comp, template<class>class Allc
+ class Comp, template<class>class Allc
>
         class IntervalMap
>
@@ -713,7 +713,7 @@
         template
         <
             class DomT, template<class>class Interv,
- template<class>class Comp, template<class>class Allc
+ class Comp, template<class>class Allc
>
         class IntervalSet
>
@@ -854,7 +854,7 @@
template
<
     class SubType, class DomainT, class CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare,
+ template<class>class Interval, class Compare,
     template<class>class Alloc
>
typename interval_base_map<SubType,DomainT,CodomainT,Traits,
@@ -874,7 +874,7 @@
template
<
     class SubType, class DomainT, class CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare,
+ template<class>class Interval, class Compare,
     template<class>class Alloc
>
typename interval_base_map<SubType,DomainT,CodomainT,Traits,
@@ -894,7 +894,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
bool interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>::contained_in(const interval_base_map& super)const
{
@@ -911,7 +911,7 @@
     class SubType,
     class DomainT, class CodomainT,
     class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
     template
     <
@@ -919,7 +919,7 @@
         <
             class DomT, class CodomT,
             class Trts, template<class>class Interv,
- template<class>class Comp, template<class>class Allc
+ class Comp, template<class>class Allc
>
         class IntervalMap
>
@@ -946,7 +946,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_intersection(interval_base_map& section,
@@ -981,7 +981,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_intersection(interval_base_map& section,
@@ -1008,7 +1008,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::join()
@@ -1057,7 +1057,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
std::string interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>::as_string()const
{
@@ -1077,7 +1077,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
CodomainT interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>::sum()const
{
@@ -1091,7 +1091,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>::uniformBounds( typename interval<DomainT>::bound_types bt)
{
@@ -1103,7 +1103,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>::closeLeftBounds()
{
@@ -1117,7 +1117,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::erase(const interval_type& x_itv)
@@ -1155,7 +1155,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
SubType&
interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>
@@ -1179,7 +1179,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& lhs,
                          const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& rhs)
@@ -1195,7 +1195,7 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& lhs,
                               const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& rhs)
@@ -1216,21 +1216,22 @@
template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
inline bool operator < (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& lhs,
                         const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& rhs)
{
     return std::lexicographical_compare(
         lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<std::pair<Interval<DomainT>, CodomainT> >()
- );
+ std::less<std::pair<Interval<DomainT>, CodomainT> >() //JODO URG
+ );
+ //NOTE DESIGN: case against class Compare parameter!
}

template
<
     class SubType,
- class DomainT, class CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc
+ class DomainT, class CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc
>
inline bool operator <= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& lhs,
                         const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Alloc>& rhs)
@@ -1246,7 +1247,7 @@
     class SubType,
     class DomainT, class CodomainT,
     class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
interval_base_map<SubType,DomainT,CodomainT,
                   Traits,Interval,Compare,Alloc>&
@@ -1271,7 +1272,7 @@
     class SubType,
     class DomainT, class CodomainT,
     class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
interval_base_map<SubType,DomainT,CodomainT,
                   Traits,Interval,Compare,Alloc>&
@@ -1295,7 +1296,7 @@

template<class CharType, class CharTraits,
     class SubType, class DomainT, class CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare,
+ template<class>class Interval, class Compare,
     template<class>class Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
   (std::basic_ostream<CharType, CharTraits>& stream,

Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2008-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -103,7 +103,7 @@
     typename SubType,
     typename DomainT,
     template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
     template<class>class Alloc = std::allocator
>
#ifdef USE_CONCEPTS
@@ -135,7 +135,7 @@

     /// Comparison functor for domain values
- typedef Compare<DomainT> domain_compare;
+ typedef Compare domain_compare;
     /// Comparison functor for intervals
     typedef exclusive_less<interval_type> interval_compare;

@@ -149,10 +149,10 @@
     typedef Alloc<DomainT> domain_allocator_type;

     /// The type of the set of elements that is equivalent to the set of intervals
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> element_set;
+ typedef typename itl::set<DomainT,Compare,Alloc> element_set;

     /// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> atomized_type;
+ typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;

     /// Container type for the implementation
     typedef typename itl::set<interval_type,exclusive_less<interval_type>,Alloc> ImplSetT;
@@ -437,7 +437,7 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
typename interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::size_type
interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::cardinality()const
@@ -468,7 +468,7 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
typename
     interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::difference_type
@@ -484,7 +484,7 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
bool interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
     ::contained_in(const interval_base_set& x2)const
@@ -510,7 +510,7 @@

template<class SubType,
- class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::add_intersection(interval_base_set& section, const value_type& x)const
{
     // any intersection with the empty intervall is empty
@@ -530,7 +530,7 @@

template<class SubType,
- class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::join()
{
     iterator it=_set.begin();
@@ -573,7 +573,7 @@

template<class SubType,
- class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::uniform_bounds(typename interval<DomainT>::bound_types bt)
{
     // I can do this only, because I am shure that the contents and the
@@ -583,7 +583,7 @@

template<class SubType,
- class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
inline bool operator == (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& lhs,
                          const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
{
@@ -596,16 +596,16 @@
}

template<class SubType,
- class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
inline bool operator < (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& lhs,
                         const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
{
     return std::lexicographical_compare(
- lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), Compare<Interval<DomainT> >());
+ lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), std::less<Interval<DomainT> >()); //JODO URG
}

template<class SubType,
- class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
inline bool operator <= (const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& lhs,
                          const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
{
@@ -615,7 +615,7 @@

template<class CharType, class CharTraits,
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
   (std::basic_ostream<CharType, CharTraits>& stream,
    const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object)

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2008-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -108,7 +108,7 @@
     typename CodomainT,
     class Traits = itl::neutron_absorber,
     template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
     template<class>class Alloc = std::allocator
>
class interval_map:
@@ -242,7 +242,7 @@
} ;

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::contains_(const value_type& interv_value)const
{
@@ -256,7 +256,7 @@
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::getResiduals(const interval_type& x_itv, interval_type& leftResid, interval_type& rightResid)
{
     iterator fst_it = this->_map.lower_bound(x_itv);
@@ -285,7 +285,7 @@

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::joinable(const iterator& some, const iterator& next)const
{
@@ -295,7 +295,7 @@
}

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::iterator
     interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::joint_insert(iterator& left_it, const iterator& right_it)
@@ -325,7 +325,7 @@

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::join_left(iterator& it)
{
@@ -347,7 +347,7 @@
}

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::join_right(iterator& it)
{
@@ -369,7 +369,7 @@

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::fill_join_left(const value_type& value)
@@ -388,7 +388,7 @@
}

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::fill_join_both(const value_type& value)
@@ -408,7 +408,7 @@

//-----------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
@@ -436,7 +436,7 @@
}

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
@@ -467,7 +467,7 @@
//-----------------------------------------------------------------------------
// add<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_(const value_type& x, const Combiner& combine)
@@ -566,7 +566,7 @@
     }
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it, const Combiner& combine)
@@ -599,7 +599,7 @@
     add_rear(x_rest, x_val, it, combine);
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_rear(const interval_type& x_rest, const CodomainT& x_val, iterator& it, const Combiner& combine)
@@ -641,7 +641,7 @@
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::subtract_(const value_type& x, const Combiner& combine)
@@ -710,7 +710,7 @@

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::subtract_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it, const Combiner& combine)
@@ -782,7 +782,7 @@
// insert(pair(interval,value)):
//-----------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::insert_(const value_type& x)
{
@@ -847,7 +847,7 @@

template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::insert_rest(const interval_type& x_itv, const CodomainT& x_val,
                   iterator& it, iterator& end_it)
@@ -875,7 +875,7 @@
}

template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::insert_rear(const interval_type& x_rest, const CodomainT& x_val,
                   iterator& it)
@@ -905,7 +905,7 @@
//-----------------------------------------------------------------------------
// erase(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::erase_(const value_type& x)
{
@@ -964,7 +964,7 @@
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_map<DomainT,CodomainT,Traits,Interval,Compare,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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -17,7 +17,7 @@
template
<
     class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
class interval_map;

@@ -33,7 +33,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -63,7 +63,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -103,7 +103,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -132,7 +132,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -174,7 +174,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -200,7 +200,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -229,7 +229,7 @@
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -257,7 +257,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -358,13 +358,13 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class LeftIntervalMap,
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class RightIntervalMap
>
@@ -393,7 +393,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -441,7 +441,7 @@
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -490,7 +490,7 @@
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2008-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -104,7 +104,7 @@
<
     typename DomainT,
     template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
     template<class>class Alloc = std::allocator
>
class interval_set:
@@ -129,7 +129,7 @@
     typedef Interval<DomainT> interval_type;

     /// Comparison functor for domain values
- typedef Compare<DomainT> domain_compare;
+ typedef Compare domain_compare;
     /// Comparison functor for intervals
     typedef exclusive_less<interval_type> interval_compare;

@@ -143,10 +143,10 @@
     typedef Alloc<DomainT> domain_allocator_type;

     /// The type of the set of elements that is equivalent to the set of intervals
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> element_set;
+ typedef typename itl::set<DomainT,Compare,Alloc> element_set;

     /// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> atomized_type;
+ typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;

     /// Container type for the implementation
     typedef typename itl::set<interval_type,exclusive_less<interval_type>,Alloc> ImplSetT;
@@ -221,7 +221,7 @@

-template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
bool interval_set<DomainT,Interval,Compare,Alloc>::contains_(const interval_type& x)const
{
     // Emptiness is contained in everything
@@ -243,7 +243,7 @@
}

-template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_set<DomainT,Interval,Compare,Alloc>::handle_neighbours(const iterator& it)
{
     if(it == this->_set.begin())
@@ -284,7 +284,7 @@

-template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
typename interval_set<DomainT,Interval,Compare,Alloc>::iterator
     interval_set<DomainT,Interval,Compare,Alloc>
     ::joint_insert(const iterator& left_it, const iterator& right_it)
@@ -305,7 +305,7 @@
}

-template<class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template<class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_set<DomainT,Interval,Compare,Alloc>::add_(const value_type& x)
{
     if(x.empty()) return;
@@ -338,7 +338,7 @@
}

-template<class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template<class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void interval_set<DomainT,Interval,Compare,Alloc>::subtract_(const value_type& x)
{
     if(x.empty()) return;
@@ -365,7 +365,7 @@
// equality of elements
//-----------------------------------------------------------------------------
template <typename DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
inline bool is_element_equal(const interval_set<DomainT,Interval,Compare,Alloc>& lhs,
                              const interval_set<DomainT,Interval,Compare,Alloc>& 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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -15,7 +15,7 @@
{

template<typename, template<class>class,
- template<class>class, template<class>class>
+ class, template<class>class>
class interval_set;

//-----------------------------------------------------------------------------
@@ -24,11 +24,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -50,11 +50,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -72,11 +72,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -97,11 +97,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -123,11 +123,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -145,11 +145,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -170,11 +170,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -217,11 +217,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -250,11 +250,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -276,11 +276,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -301,11 +301,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -343,11 +343,11 @@
<
     class SubType, class DomainT, class CodomainT,
     class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, class, class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalMap
>
@@ -392,11 +392,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -416,11 +416,11 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -441,11 +441,11 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc,
+ class Compare, template<class>class Alloc,
     template
     <
         class, template<class>class,
- template<class>class, template<class>class
+ class, template<class>class
>
     class IntervalSet
>
@@ -462,7 +462,7 @@
template
<
     class SubType, class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
typename interval_base_set<SubType,DomainT,Interval,Compare,Alloc>::interval_type
enclosure(const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object)

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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -68,7 +68,7 @@
<
     typename DomainT,
     template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
     template<class>class Alloc = std::allocator
>
class separate_interval_set:
@@ -94,7 +94,7 @@
     typedef Interval<DomainT> interval_type;

     /// Comparison functor for domain values
- typedef Compare<DomainT> domain_compare;
+ typedef Compare domain_compare;
     /// Comparison functor for intervals
     typedef exclusive_less<interval_type> interval_compare;

@@ -108,10 +108,10 @@
     typedef Alloc<DomainT> domain_allocator_type;

     /// The type of the set of elements that is equivalent to the set of intervals
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> element_set;
+ typedef typename itl::set<DomainT,Compare,Alloc> element_set;

     /// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> atomized_type;
+ typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;

     /// Container type for the implementation
     typedef typename itl::set<interval_type,exclusive_less<interval_type>,Alloc> ImplSetT;
@@ -180,7 +180,7 @@
} ;

-template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
bool separate_interval_set<DomainT,Interval,Compare,Alloc>::contains_(const interval_type& interv)const
{
     if(interv.empty())
@@ -192,7 +192,7 @@
}

-template<class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template<class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void separate_interval_set<DomainT,Interval,Compare,Alloc>::add_(const value_type& x)
{
     if(x.empty()) return;
@@ -225,7 +225,7 @@
}

-template<class DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template<class DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
void separate_interval_set<DomainT,Interval,Compare,Alloc>::subtract_(const value_type& x)
{
     if(x.empty()) return;
@@ -255,7 +255,7 @@
template
<
     class DomainT, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc
+ class Compare, template<class>class Alloc
>
inline bool
is_element_equal

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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -130,7 +130,7 @@
         typename CodomainT,
         class Traits = itl::neutron_absorber,
         template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
         template<class>class Alloc = std::allocator
>
     class split_interval_map:
@@ -244,7 +244,7 @@
     } ;

- template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     bool split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
         ::contains_(const value_type& interv_value)const
     {
@@ -260,7 +260,7 @@

- template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>::getResiduals(const interval_type& x_itv, interval_type& leftResid, interval_type& rightResid)
     {
         iterator fst_it = this->_map.lower_bound(x_itv);
@@ -289,7 +289,7 @@

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::fill(const value_type& value)
{
@@ -302,7 +302,7 @@
}

template <typename DomainT, typename CodomainT, class Traits,
- template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::fill_gap(const value_type& value, const Combiner& combine)
@@ -326,7 +326,7 @@
//-----------------------------------------------------------------------------
// add<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_(const value_type& x, const Combiner& combine)
@@ -410,7 +410,7 @@
     }
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_rest(const interval_type& x_itv, const CodomainT& x_val,
@@ -440,7 +440,7 @@
     add_rear(x_rest, x_val, it, combine);
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::add_rear(const interval_type& x_rest, const CodomainT& x_val, iterator& it,
@@ -476,7 +476,7 @@
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::subtract_(const value_type& x, const Combiner& combine)
@@ -535,7 +535,7 @@

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
     template<class Combiner>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::subtract_rest(const interval_type& x_itv, const CodomainT& x_val,
@@ -589,7 +589,7 @@
// insert(pair(interval,value)):
//-----------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::insert_(const value_type& x)
{
@@ -646,7 +646,7 @@

template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::insert_rest(const interval_type& x_itv, const CodomainT& x_val,
                   iterator& it, iterator& end_it)
@@ -667,7 +667,7 @@
}

template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval,
- template<class>class Compare, template<class>class Alloc>
+ class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::insert_rear(const interval_type& x_rest, const CodomainT& x_val,
                   iterator& it)
@@ -690,7 +690,7 @@
//-----------------------------------------------------------------------------
// erase(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::erase_(const value_type& x)
{
@@ -749,7 +749,7 @@
}

-template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+template <typename DomainT, typename CodomainT, class Traits, template<class>class Interval, class Compare, template<class>class Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Alloc>
     ::erase_rest(const interval_type& x_itv, const CodomainT& x_val,
                  iterator& it, iterator& end_it)

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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -89,7 +89,7 @@
     <
         typename DomainT,
         template<class>class Interval = itl::interval,
- template<class>class Compare = std::less,
+ class Compare = std::less<DomainT>,
         template<class>class Alloc = std::allocator
>
     class split_interval_set:
@@ -112,7 +112,7 @@
         typedef Interval<DomainT> interval_type;

         /// Comparison functor for domain values
- typedef Compare<DomainT> domain_compare;
+ typedef Compare domain_compare;
         /// Comparison functor for intervals
         typedef exclusive_less<interval_type> interval_compare;

@@ -126,10 +126,10 @@
         typedef Alloc<DomainT> domain_allocator_type;

         /// The type of the set of elements that is equivalent to the set of intervals
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> element_set;
+ typedef typename itl::set<DomainT,Compare,Alloc> element_set;

         /// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare<DomainT>,Alloc> atomized_type;
+ typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;

         /// Container type for the implementation
         typedef typename itl::set<interval_type,exclusive_less<interval_type>,Alloc> ImplSetT;
@@ -199,7 +199,7 @@
         void subtract_rest(const interval_type& x_itv, iterator& it, iterator& end_it);
     } ;

- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     bool split_interval_set<DomainT,Interval,Compare,Alloc>::contains_(const interval_type& interv)const
     {
         if(interv.empty())
@@ -211,7 +211,7 @@
     }

- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     void split_interval_set<DomainT,Interval,Compare,Alloc>::add_(const value_type& x)
     {
         if(x.empty()) return;
@@ -273,7 +273,7 @@
     }

- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     void split_interval_set<DomainT,Interval,Compare,Alloc>::insert_rest(const interval_type& x_itv, iterator& it, iterator& end_it)
     {
         iterator nxt_it = it; nxt_it++;
@@ -314,7 +314,7 @@
     }

- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     void split_interval_set<DomainT,Interval,Compare,Alloc>::subtract_(const value_type& x)
     {
         if(x.empty()) return;
@@ -365,7 +365,7 @@

- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     void split_interval_set<DomainT,Interval,Compare,Alloc>::subtract_rest(const interval_type& x_itv, iterator& snd_it, iterator& end_it)
     {
         iterator it=snd_it, nxt_it=snd_it; nxt_it++;
@@ -400,7 +400,7 @@
         NOTE: This is not inline with the mathematical view.
         We have a distiction between 'element equality' and 'lexicographical
         equality'. */
- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     inline bool operator == (const split_interval_set<DomainT,Interval,Compare,Alloc>& lhs,
                              const split_interval_set<DomainT,Interval,Compare,Alloc>& rhs)
     {
@@ -413,7 +413,7 @@
     }

- template <typename DomainT, template<class>class Interval, template<class>class Compare, template<class>class Alloc>
+ template <typename DomainT, template<class>class Interval, class Compare, template<class>class Alloc>
     inline bool operator < (const split_interval_set<DomainT,Interval,Compare,Alloc>& lhs,
                             const split_interval_set<DomainT,Interval,Compare,Alloc>& rhs)
     {
@@ -422,7 +422,7 @@
         return std::lexicographical_compare(
             lhs_joined.begin(), lhs_joined.end(),
             rhs_joined.begin(), rhs_joined.end(),
- Compare<Interval<DomainT> >());
+ std::less<Interval<DomainT> >()); //JODO URG
     }

     template <class Type>

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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -13,7 +13,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -160,7 +160,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -221,7 +221,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -274,7 +274,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -305,7 +305,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -354,7 +354,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -405,7 +405,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -447,7 +447,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -509,7 +509,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -620,7 +620,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>
@@ -735,7 +735,7 @@
template <template<class T, class U,
                    class Traits = neutron_absorber,
                    template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                    template<class>class = std::allocator
>class IntervalMap,
           class T, class U>

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-11-11 14:32:26 EST (Tue, 11 Nov 2008)
@@ -10,7 +10,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -142,7 +142,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -193,7 +193,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -235,7 +235,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -261,7 +261,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -302,7 +302,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -346,7 +346,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -384,7 +384,7 @@

template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>
@@ -427,7 +427,7 @@

// Test for nontrivial intersection of interval sets with intervals and values
template <template<class T, template<class>class = interval,
- template<class>class = std::less,
+ class = std::less<T>,
                             template<class>class = std::allocator
>class IntervalSet,
           class T>

Next message: nielsdekker_at_[hidden]: "[Boost-commit] svn:boost r49688 - trunk/status"
Previous message: eric_at_[hidden]: "[Boost-commit] svn:boost r49686 - in trunk/boost/proto: . detail transform"

Date view	Thread view	Subject view	Author view

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