Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r64456 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/itl_xt boost/itl_xt/detail boost/validate/driver boost/validate/itl boost/validate/laws boost/validate/validater libs/itl/example/boost_party_ libs/itl/example/interval_ libs/itl/example/man_power_ libs/itl/test libs/itl/test/test_casual_ libs/validate/example/boostcon_law_validater_ libs/validate/example/labat_map_copy_conformity_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2010-07-29 17:18:25


Author: jofaber
Date: 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
New Revision: 64456
URL: http://svn.boost.org/trac/boost/changeset/64456

Log:
Updated the test suite for the new types discrete_interval and continuous_interval.
Added:
   sandbox/itl/boost/itl/type_traits/is_discrete.hpp (contents, props changed)
Text files modified:
   sandbox/itl/boost/itl/continuous_interval.hpp | 5
   sandbox/itl/boost/itl/detail/design_config.hpp | 48 +++
   sandbox/itl/boost/itl/detail/element_iterator.hpp | 12
   sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 12
   sandbox/itl/boost/itl/detail/map_algo.hpp | 6
   sandbox/itl/boost/itl/detail/set_algo.hpp | 6
   sandbox/itl/boost/itl/discrete_interval.hpp | 18
   sandbox/itl/boost/itl/functions.hpp | 58 +++
   sandbox/itl/boost/itl/interval.hpp | 2
   sandbox/itl/boost/itl/interval_base_map.hpp | 19
   sandbox/itl/boost/itl/interval_base_set.hpp | 6
   sandbox/itl/boost/itl/interval_functions.hpp | 33 +-
   sandbox/itl/boost/itl/interval_set.hpp | 6
   sandbox/itl/boost/itl/map.hpp | 26 ++
   sandbox/itl/boost/itl/rightopen_interval.hpp | 6
   sandbox/itl/boost/itl/set.hpp | 25 +
   sandbox/itl/boost/itl/type_traits/interval_type_of.hpp | 2
   sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp | 4
   sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 6
   sandbox/itl/boost/itl_xt/interval_bitset.hpp | 18 +
   sandbox/itl/boost/itl_xt/mapgentor.hpp | 2
   sandbox/itl/boost/itl_xt/setgentor.hpp | 2
   sandbox/itl/boost/validate/driver/itl_driver.hpp | 8
   sandbox/itl/boost/validate/itl/functors.hpp | 12
   sandbox/itl/boost/validate/laws/law_violations.hpp | 4
   sandbox/itl/boost/validate/validater/law_validater.hpp | 4
   sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp | 2
   sandbox/itl/libs/itl/example/interval_/interval.cpp | 14
   sandbox/itl/libs/itl/example/man_power_/man_power.cpp | 4
   sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 13
   sandbox/itl/libs/itl/test/test_functions.hpp | 3
   sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 516 +++++++++++++++++++++------------------
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 152 ++++++----
   sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp | 154 ++++++++---
   sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 104 +++++--
   sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp | 5
   sandbox/itl/libs/itl/test/test_set_itl_set.hpp | 5
   sandbox/itl/libs/itl/test/test_value_maker.hpp | 13
   sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp | 2
   sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj | 4
   sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 18
   41 files changed, 847 insertions(+), 512 deletions(-)

Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -68,6 +68,11 @@
     domain_type upper()const { return _upb; }
     interval_bounds bounds()const{ return _bounds; }
 
+ static continuous_interval open (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::open()); }
+ static continuous_interval rightopen(const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::right_open());}
+ static continuous_interval leftopen (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::left_open()); }
+ static continuous_interval closed (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::closed()); }
+
 private:
     domain_type _lwb;
     domain_type _upb;

Modified: sandbox/itl/boost/itl/detail/design_config.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/design_config.hpp (original)
+++ sandbox/itl/boost/itl/detail/design_config.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -23,16 +23,47 @@
 // will be used as default for all interval containers.
 // ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS should be defined in the application
 // before other includes from the ITL
-//#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
+//#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS //JODO comment this out for the final release
 // If ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS is NOT defined, ITL uses intervals
 // with dynamic borders as default.
 
+#ifdef ITL_USE_DYNAMIC_INTERVAL_BORDERS_DEFAULTS //JODO remove this for the final release
+# undef ITL_USE_STATIC_INTERVAL_BORDERS_DEFAULTS
+#endif
+
+//#define ITL_CONCEPT_ORIENTED
+//#define ITL_PURE_CONCEPTUAL
+
+#ifndef ITL_CONCEPT_ORIENTED
+#define ITL_OBJECT_ORIENTED
+#endif
+
+#ifdef ITL_CONCEPT_ORIENTED
+# define ITL_FUN_CALL(func, arg) itl::func(arg)
+# define ITL_FUN_REN(func_obj, func_conc, arg) itl::func_conc(arg)
+#else //ITL_OBJECT_ORIENTED
+# define ITL_FUN_CALL(func,arg) arg.func()
+# define ITL_FUN_REN(func_obj, func_conc, arg) arg.func_obj()
+#endif
+
+#ifdef ITL_OBJECT_ORIENTED
+# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS public
+# define ITL_END_COMMON_MEMBER_FUNCTIONS public
+#else //ITL_CONCEPT_ORIENTED
+# ifdef ITL_PURE_CONCEPTUAL
+# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS private
+# define ITL_END_COMMON_MEMBER_FUNCTIONS public
+# else
+# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS public
+# define ITL_END_COMMON_MEMBER_FUNCTIONS public
+# endif
+#endif
 
 //------------------------------------------------------------------------------
 // Auxiliary macros for denoting template signatures.
 // Purpose:
 // (1) Shorten the lenthy and redundant template signatures.
-// (2) Name anonymous template types according to theirs meaning ...
+// (2) Name anonymous template types according to their meaning ...
 // (3) Making easier to refactor by redefinitin of the macros
 // (4) Being able to check template template parameter variants against
 // template type parameter variants.
@@ -114,7 +145,7 @@
 //CL #define ITL_INTERVAL_DEFAULT itl::continuous_interval
 
 #ifdef ITL_NEW_INTERVAL_IMPL
-# define ITL_INTERVAL_DEFAULT itl::interval_type_of
+# define ITL_INTERVAL_DEFAULT boost::itl::interval_type_of
 #else
 # define ITL_INTERVAL_DEFAULT boost::itl::interval
 #endif
@@ -122,10 +153,13 @@
 //------------------------------------------------------------------------------
 //JODO find proper solution here
 #ifdef ITL_NEW_INTERVAL_IMPL
-//# define ITL_discrt_INTERVAL_DEF itl::discrete_interval
-//# define ITL_contin_INTERVAL_DEF itl::continuous_interval
-# define ITL_discrt_INTERVAL_DEF itl::rightopen_interval
-# define ITL_contin_INTERVAL_DEF itl::rightopen_interval
+# ifdef ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
+# define ITL_discrt_INTERVAL_DEF itl::rightopen_interval
+# define ITL_contin_INTERVAL_DEF itl::rightopen_interval
+# else
+# define ITL_discrt_INTERVAL_DEF itl::discrete_interval
+# define ITL_contin_INTERVAL_DEF itl::continuous_interval
+# endif
 #else
 # define ITL_discrt_INTERVAL_DEF itl::interval
 # define ITL_contin_INTERVAL_DEF itl::interval

Modified: sandbox/itl/boost/itl/detail/element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_iterator.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_iterator.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -199,13 +199,13 @@
 
     static domain_type first (const SegmentIteratorT& leaper){ return leaper->first(); }
     static domain_type last (const SegmentIteratorT& leaper){ return leaper->last(); }
- static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(*leaper);}
+ static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(*leaper);}
 
     static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
                                           const domain_difference_type& sneaker)
     {
- inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(*leaper) - sneaker
- : itl::first(*leaper) + sneaker;
+ inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(*leaper) - sneaker
+ : itl::first(*leaper) + sneaker;
         return inter_pos;
     }
 };
@@ -223,13 +223,13 @@
 
     static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); }
     static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); }
- static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(leaper->first);}
+ static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(leaper->first);}
 
     static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
                                           const domain_difference_type& sneaker)
     {
- inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(leaper->first) - sneaker
- : itl::first(leaper->first) + sneaker;
+ inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(leaper->first) - sneaker
+ : itl::first(leaper->first) + sneaker;
         return transit_type(inter_pos, leaper->second);
     }
 };

Modified: sandbox/itl/boost/itl/detail/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_set_algo.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -29,7 +29,8 @@
     size_type interval_size;
     ITL_const_FORALL(typename IntervalContainerT, it, object)
     {
- interval_size = continuous_interval_<interval_type>::cardinality(IntervalContainerT::key_value(it));
+ //CL interval_size = continuous_interval_<interval_type>::cardinality(IntervalContainerT::key_value(it));
+ interval_size = itl::cardinality(IntervalContainerT::key_value(it));
         if(interval_size == infinity<size_type>::value())
             return interval_size;
         else
@@ -172,13 +173,15 @@
         {
             if(IntervalContainerT::codomain_value(next_) != co_value)
                 return false;
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
                 return false;
         }
     }
     else
         while(next_ != container.end() && it_ != past)
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
                 return false;
 
     return true;
@@ -201,7 +204,8 @@
     ++next_;
 
     while(next_ != container.end() && it_ != past)
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
             return false;
 
     return true;

Modified: sandbox/itl/boost/itl/detail/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/map_algo.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -28,8 +28,8 @@
 bool contained_in(const MapType& sub, const MapType& super)
 {
     if(&super == &sub) return true;
- if(sub.empty()) return true;
- if(super.empty()) return false;
+ if(ITL_FUN_REN(empty, is_empty, sub)) return true;
+ if(ITL_FUN_REN(empty, is_empty, super)) return false;
     if(super.size() < sub.size() ) return false;
     if(*sub.begin() < *super.begin()) return false;
     if(*super.rbegin() < *sub.rbegin() ) return false;
@@ -120,7 +120,7 @@
 {
     if(mpl::and_<is_total<MapType>, absorbs_neutrons<MapType> >::value)
     {
- result.clear();
+ ITL_FUN_CALL(clear, result);
         return;
     }
 

Modified: sandbox/itl/boost/itl/detail/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/set_algo.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -36,7 +36,7 @@
             lwb = x1.end();
             upb = x1.end();
 
- if(x1.empty() || x2.empty())
+ if(ITL_FUN_REN(empty, is_empty, x1) || ITL_FUN_REN(empty, is_empty, x2))
                 return false;
 
             IteratorT x1_fst_ = x1.begin();
@@ -115,8 +115,8 @@
         bool contained_in(const SetType& sub, const SetType& super)
         {
             if(&super == &sub) return true;
- if(sub.empty()) return true;
- if(super.empty()) return false;
+ if(ITL_FUN_REN(empty, is_empty, sub)) return true;
+ if(ITL_FUN_REN(empty, is_empty, super)) return false;
             if(*sub.begin() < *super.begin()) return false;
             if(*super.rbegin() < *sub.rbegin() ) return false;
 

Modified: sandbox/itl/boost/itl/discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/discrete_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -70,20 +70,22 @@
     domain_type upper()const { return _upb; }
     interval_bounds bounds()const{ return _bounds; }
 
+ /*CL
     domain_type first()const
- {
- return _bounds.left().bits()==2 ? _lwb : succ(_lwb);
- }
+ {
+ return _bounds.left().bits()==2 ? _lwb : succ(_lwb);
+ }
 
     DomainT last()const
     {
- return _bounds.right().bits()==1 ? _upb : pred(_upb);
+ return _bounds.right().bits()==1 ? _upb : pred(_upb);
     }
+ */
 
- static discrete_interval open (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::open()); }
- static discrete_interval rightopen(const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::right_open());}
- static discrete_interval leftopen (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::left_open()); }
- static discrete_interval closed (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::closed()); }
+ static discrete_interval open (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::open()); }
+ static discrete_interval rightopen(const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::right_open());}
+ static discrete_interval leftopen (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::left_open()); }
+ static discrete_interval closed (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::closed()); }
 
 private:
     domain_type _lwb;

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -1,5 +1,5 @@
 /*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
 +------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
@@ -17,6 +17,49 @@
 namespace boost{namespace itl
 {
 
+//==========================================================================
+//= Containedness
+//==========================================================================
+
+/** All content of the container is dropped.
+ Complexity: linear. */
+template<class ObjectT>
+typename boost::enable_if<is_interval_container<ObjectT>, void>::type
+clear(ObjectT& object) //JODO test
+{
+#ifdef ITL_CONCEPT_ORIENTED //JODO find final decision
+ object.erase(object.begin(), object.end());
+#else //ITL_OBJECT_ORIENTED
+ object.clear();
+#endif
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template<class ObjectT>
+typename boost::enable_if<is_interval_container<ObjectT>, bool>::type
+is_empty(const ObjectT& object)
+{
+#ifdef ITL_CONCEPT_ORIENTED //JODO find final decision
+ return object.begin() == object.end();
+#else //ITL_OBJECT_ORIENTED
+ return object.empty();
+#endif
+}
+
+/** Does \c super contain \c sub?
+ Complexity: linear. */
+//template<class ObjectT>
+//typename boost::enable_if<is_interval_container<ObjectT>, bool>::type
+//contains(const ObjectT& super, const ObjectT& sub)
+//{
+//#ifdef ITL_CONCEPT_ORIENTED
+// return true; //JODO
+//#else //ITL_OBJECT_ORIENTED
+// return super.contains(sub);
+//#endif
+//}
+
 //==============================================================================
 //= Equivalences and Orderings
 //==============================================================================
@@ -320,7 +363,7 @@
                           ObjectT>::type&
 erase(ObjectT& object, const OperandT& operand)
 {
- if(operand.empty())
+ if(ITL_FUN_REN(empty, is_empty, operand))
         return object;
 
     typename OperandT::const_iterator common_lwb;
@@ -402,7 +445,7 @@
     while(it_ != right_common_upper_)
     {
         left.add_intersection(intersection, *it_++);
- if(!intersection.empty())
+ if(!ITL_FUN_REN(empty, is_empty, intersection))
             return true;
     }
 
@@ -421,7 +464,7 @@
 {
     LeftT intersection;
 
- if(left.empty() || right.empty())
+ if(ITL_FUN_REN(empty, is_empty, left) || ITL_FUN_REN(empty, is_empty, right))
         return false;
 
     typename RightT::const_iterator right_common_lower_;
@@ -434,7 +477,7 @@
     while(it_ != right_common_upper_)
     {
         left.add_intersection(intersection, RightT::key_value(it_++));
- if(!intersection.empty())
+ if(!ITL_FUN_REN(empty, is_empty, intersection))
             return true;
     }
 
@@ -528,9 +571,8 @@
 hull(const ObjectT& object)
 {
     return
- object.empty() ? neutron<typename ObjectT::interval_type>::value()
- : (ObjectT::key_value(object.begin()))
- .span(ObjectT::key_value(object.rbegin()));
+ ITL_FUN_REN(empty, is_empty, object) ? neutron<typename ObjectT::interval_type>::value()
+ : hull((ObjectT::key_value(object.begin())), ObjectT::key_value(object.rbegin()));
 }
 
 

Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -502,7 +502,7 @@
     static typename IntervalT::size_type cardinality(const IntervalT& x)
     {
         typedef typename IntervalT::size_type SizeT;
- if(x.empty())
+ if(itl::is_empty(x))
             return itl::neutron<SizeT>::value();
         else if(x.is(itl::closed_bounded) && IntervalT::domain_equal(x.lower(), x.upper()))
             return itl::unon<SizeT>::value();

Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -219,13 +219,14 @@
     //==========================================================================
     //= Containedness
     //==========================================================================
-
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
     /** clear the map */
     void clear() { _map.clear(); }
 
     /** is the map empty? */
     bool empty()const { return _map.empty(); }
 
+ITL_END_COMMON_MEMBER_FUNCTIONS:
     //--- contains: set view ---------------------------------------------------
     /** Does the map contain the domain element \c key? */
     bool contains(const domain_type& key)const
@@ -246,7 +247,7 @@
         const_iterator last_overlap = prior(exterior.second);
 
         return
- hull(exterior.first->first, last_overlap->first).contains(sub_interval)
+ itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
         && Interval_Set::is_dense(*this, exterior.first, last_overlap);
     }
 
@@ -492,7 +493,7 @@
     {
         typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> operand_type;
 
- if(operand.empty())
+ if(ITL_FUN_REN(empty, is_empty, operand))
             return *that();
 
         typename operand_type::const_iterator common_lwb;
@@ -556,7 +557,7 @@
     )const
     {
         typedef IntervalSet<DomainT,Compare,Interval,Alloc> sectant_type;
- if(sectant.empty())
+ if(ITL_FUN_REN(empty, is_empty, sectant))
             return;
 
         typename sectant_type::const_iterator common_lwb;
@@ -621,7 +622,7 @@
 
         type intersection;
         add_intersection(intersection, interval_value_pair);
- return !itl::is_empty(intersection);
+ return !ITL_FUN_REN(empty, is_empty, intersection);
     }
 
 
@@ -877,8 +878,8 @@
         return false;
 
     return
- hull(exterior.first->first, last_overlap->first).contains(sub_interval)
- && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
+ itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
 }
 
 
@@ -920,7 +921,7 @@
 {
     difference_type length = neutron<difference_type>::value();
     const_FOR_IMPLMAP(it_)
- length += it_->first.length();
+ length += itl::length(it_->first);
     return length;
 }
 
@@ -1099,7 +1100,7 @@
     while(it_ != end_ )
     {
         const codomain_type& co_value = it_->second;
- covered = (*it_++).first;
+ covered = (*it_++).first;
         //[a ... : span
         // [b ... : covered
         //[a b) : left_over

Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -164,11 +164,13 @@
     //= Containedness
     //==========================================================================
 
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
     /** sets the container empty */
     void clear() { _set.clear(); }
     /** is the container empty? */
     bool empty()const { return _set.empty(); }
 
+ITL_END_COMMON_MEMBER_FUNCTIONS:
     /** Does the container contain the element \c key ? */
     bool contains(const element_type& key)const
     { return that()->contains(interval_type(key)); }
@@ -186,7 +188,7 @@
         const_iterator last_overlap = prior(exterior.second);
 
         return
- hull(*(exterior.first), *last_overlap).contains(sub_interval)
+ itl::contains(hull(*(exterior.first), *last_overlap), sub_interval)
         && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
     }
 
@@ -521,7 +523,7 @@
 {
     difference_type length = neutron<difference_type>::value();
     const_FOR_IMPL(it_)
- length += (*it_).length();
+ length += itl::length(*it_);
     return length;
 }
 

Modified: sandbox/itl/boost/itl/interval_functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_functions.hpp (original)
+++ sandbox/itl/boost/itl/interval_functions.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -115,7 +115,7 @@
 typename boost::enable_if<is_discrete_interval<IntervalT>, IntervalT>::type
 construct(const typename IntervalT::domain_type& low,
           const typename IntervalT::domain_type& up,
- interval_bounds bounds = interval_bounds::right_open() )
+ interval_bounds bounds = interval_bounds::right_open() )
 {
     return construct_interval<IntervalT>::apply(low, up, bounds);
 }
@@ -158,7 +158,7 @@
                      typename IntervalT::domain_type>::type
 first(const IntervalT& object)
 {
- return object.lower();
+ return object.lower();
 }
 
 template<class IntervalT>
@@ -167,8 +167,8 @@
                      typename IntervalT::domain_type>::type
 first(const IntervalT& object)
 {
- return is_left_closed(object.bounds()) ?
- object.lower() : succ(object.lower());
+ return is_left_closed(object.bounds()) ?
+ object.lower() : succ(object.lower());
 }
 
 //- last -----------------------------------------------------------------------
@@ -179,7 +179,7 @@
                  typename IntervalT::domain_type>::type
 last(const IntervalT& object)
 {
- return pred(object.upper());
+ return pred(object.upper());
 }
 
 template<class IntervalT>
@@ -188,7 +188,7 @@
                      typename IntervalT::domain_type>::type
 last(const IntervalT& object)
 {
- return is_right_closed(object.bounds()) ? object.upper() : pred(object.upper());
+ return is_right_closed(object.bounds()) ? object.upper() : pred(object.upper());
 }
 
 
@@ -253,7 +253,14 @@
 typename boost::enable_if<is_discrete_interval<IntervalT>, bool>::type
 is_empty(const IntervalT& object)
 {
- return IntervalT::domain_less(last(object), first(object));
+ //CL return IntervalT::domain_less(last(object), first(object));
+
+ if(object.bounds() == interval_bounds::closed())
+ return IntervalT::domain_less(object.upper(), object.lower());
+ else if(object.bounds() == interval_bounds::open())
+ return IntervalT::domain_less_equal(object.upper(), succ(object.lower()));
+ else
+ return IntervalT::domain_less_equal(object.upper(), object.lower());
 }
 
 template<class IntervalT>
@@ -584,7 +591,7 @@
     typename IntervalT::size_type>::type
 cardinality(const IntervalT& object)
 {
- return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
+ return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
 }
 
 
@@ -605,7 +612,7 @@
     typename IntervalT::size_type>::type
 cardinality(const IntervalT& object)
 {
- return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
+ return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
 }
 
 
@@ -625,7 +632,7 @@
     typename IntervalT::difference_type>::type
 length(const IntervalT& object)
 {
- return object.upper() - object.lower();
+ return object.upper() - object.lower();
 }
 
 template<class IntervalT>
@@ -633,7 +640,7 @@
     typename IntervalT::difference_type>::type
 length(const IntervalT& object)
 {
- return (last(object) + itl::unon<IntervalT::difference_type>::value())
+ return (last(object) + itl::unon<IntervalT::difference_type>::value())
             - first(object);
 }
 
@@ -642,7 +649,7 @@
     typename IntervalT::difference_type>::type
 length(const IntervalT& object)
 {
- return object.upper() - object.lower();
+ return object.upper() - object.lower();
 }
 
 template<class IntervalT>
@@ -650,7 +657,7 @@
     typename IntervalT::difference_type>::type
 length(const IntervalT& object)
 {
- return (last(object) + itl::unon<IntervalT::difference_type>::value())
+ return (last(object) + itl::unon<IntervalT::difference_type>::value())
             - first(object);
 }
 

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -212,8 +212,8 @@
     ::join_on_left(iterator& left_, const iterator& right_)
 {
     // both left and right are in the set and they are neighbours
- BOOST_ASSERT((*left_).exclusive_less(*right_));
- BOOST_ASSERT((*left_).touches(*right_));
+ BOOST_ASSERT(exclusive_less(*left_, *right_));
+ BOOST_ASSERT(touches(*left_, *right_));
 
     interval_type right_itv = (*right_);
     this->_set.erase(right_);
@@ -254,7 +254,7 @@
 typename interval_set<DomainT,Compare,Interval,Alloc>::iterator
     interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
- if(boost::itl::is_empty(addend))
+ if(boost::itl::is_empty(addend))
         return prior_;
 
     iterator insertion = this->_set.insert(prior_, addend);

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -173,9 +173,11 @@
     void swap(map& src) { base_type::swap(src); }
 
     //==========================================================================
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
     using base_type::empty;
     using base_type::clear;
 
+ITL_END_COMMON_MEMBER_FUNCTIONS:
     using base_type::begin;
     using base_type::end;
     using base_type::rbegin;
@@ -715,6 +717,30 @@
 // non member functions
 //-----------------------------------------------------------------------------
 
+
+//==========================================================================
+//= Containedness
+//==========================================================================
+//JODO general container concept
+/** All content of the container is dropped.
+ Complexity: linear. */
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+void clear(itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object) //JODO test
+{
+ //object.clear();
+ object.erase(object.begin(), object.end());
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+bool is_empty(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
+{
+ //return object.empty();
+ return object.begin() == object.end();
+}
+
+
 //==============================================================================
 //= Equivalences and Orderings
 //==============================================================================

Modified: sandbox/itl/boost/itl/rightopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/rightopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/rightopen_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -63,7 +63,7 @@
     domain_type lower()const{ return _lwb; }
     domain_type upper()const{ return _upb; }
 
- /*CL
+ /*CL
     domain_type first()const{ return _lwb; }
 
     DomainT last()const
@@ -71,7 +71,7 @@
         BOOST_STATIC_ASSERT((!itl::is_continuous<DomainT>::value));
         return pred(_upb);
     }
- */
+ */
 
 private:
     domain_type _lwb;
@@ -84,7 +84,7 @@
   (std::basic_ostream<CharType, CharTraits> &stream,
    rightopen_interval<DomainT,Compare> const& object)
 {
- if(boost::itl::is_empty(object))
+ if(boost::itl::is_empty(object))
         return stream << "[)";
     else
         return stream << "[" << object.lower() << "," << object.upper()<< ")";

Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -121,9 +121,11 @@
     set& assign_if(const set& src, const Predicate&);
 
     //==========================================================================
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
     using base_type::empty;
     using base_type::clear;
 
+ITL_END_COMMON_MEMBER_FUNCTIONS:
     using base_type::begin;
     using base_type::end;
     using base_type::rbegin;
@@ -341,6 +343,29 @@
 //-----------------------------------------------------------------------------
 // non member functions
 //-----------------------------------------------------------------------------
+
+//==========================================================================
+//= Containedness
+//==========================================================================
+//JODO general container concept
+/** All content of the container is dropped.
+ Complexity: linear. */
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+void clear(itl::set<DomainT,Compare,Alloc>& object) //JODO test
+{
+ //object.clear();
+ object.erase(object.begin(), object.end());
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+bool is_empty(const itl::set<DomainT,Compare,Alloc>& object)
+{
+ //return object.empty();
+ return object.begin() == object.end();
+}
+
 //==============================================================================
 //= Equivalences and Orderings
 //==============================================================================

Modified: sandbox/itl/boost/itl/type_traits/interval_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/interval_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/interval_type_of.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -23,7 +23,7 @@
 #ifdef ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
         typedef rightopen_interval<DomainT,Compare> type;
 #else
- typedef
+ typedef
             typename mpl::if_< is_continuous<DomainT> //JODO add Traits to choose between static and dynamic intervals
                              , continuous_interval<DomainT,Compare>
                              , discrete_interval<DomainT,Compare> >::type type;

Modified: sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -33,7 +33,7 @@
             value = (type_traits::ice_and
                     <
                         is_asymmetric_interval<Type>::value
- , is_continuous<typename Type::domain_type>::value
+ , is_continuous<typename Type::domain_type>::value
>::value)
                 );
 };
@@ -45,7 +45,7 @@
             value = (type_traits::ice_and
                     <
                         is_asymmetric_interval<Type>::value
- , type_traits::ice_not<is_continuous<typename Type::domain_type>::value>::value
+ , type_traits::ice_not<is_continuous<typename Type::domain_type>::value>::value
>::value)
                 );
 };

Added: sandbox/itl/boost/itl/type_traits/is_discrete.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/is_discrete.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -0,0 +1,29 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_080910
+#define BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_080910
+
+#include <string>
+#include <boost/type_traits/is_integral.hpp>
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct is_discrete;
+
+ template<class Type> struct is_discrete
+ {
+ typedef is_discrete<Type> type;
+ BOOST_STATIC_CONSTANT(bool, value = is_integral<Type>::value);
+ };
+
+
+}} // namespace boost itl
+
+#endif
+
+

Modified: sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp (original)
+++ sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -124,7 +124,7 @@
         next_bit();
         if(_on_bit == past)
         { // The current bitset passed the end
- if(_reptator < pred(itl::length(_saltator->first)))
+ if(_reptator < pred(itl::length(_saltator->first)))
             {
                 ++_reptator;
                 _on_bit = ante;
@@ -156,7 +156,7 @@
                 --_saltator;
                 // NOW: decrement insecure, because _saltator can (finally) be
                 // begin here. increment and dereference are secure.
- _reptator = itl::length(_saltator->first);
+ _reptator = itl::length(_saltator->first);
                 --_reptator;
                 _on_bit = past;
             }
@@ -204,7 +204,7 @@
         if(_on_bit == beyond)
         {
             --_saltator;
- _reptator = itl::length(_saltator->first);
+ _reptator = itl::length(_saltator->first);
             --_reptator;
             _on_bit = Proceed::last_bit(_saltator->second.word());
         }

Modified: sandbox/itl/boost/itl_xt/interval_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/interval_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/interval_bitset.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -148,8 +148,8 @@
     interval_bitset& intersect(const element_type& rhs) {return segment_apply(&interval_bitset::intersect_,interval_type(rhs));}
     interval_bitset& flip (const element_type& rhs) {return segment_apply(&interval_bitset::flip_, interval_type(rhs));}
 
- void clear(){ _map.clear(); }
- bool empty()const{ return _map.clear(); }
+ void clear(){ ITL_FUN_CALL(clear, _map); }
+ bool empty()const{ return ITL_FUN_REN(empty, is_empty, _map); }
     size_type cardinality()const;
     size_type size()const { return cardinality(); }
     size_type interval_count()const { return _map.interval_count(); }
@@ -380,7 +380,7 @@
 {
     size_type cardinality = 0;
     ITL_const_FORALL(typename interval_bitmap_type, it_, _map)
- cardinality += (it_->second.cardinality() * itl::cardinality(it_->first));
+ cardinality += (it_->second.cardinality() * itl::cardinality(it_->first));
     return cardinality;
 }
 
@@ -415,6 +415,18 @@
                       const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& right)
 { return left == right; }
 
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+void clear(interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{
+ object.clear();
+}
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+bool is_empty(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{
+ return object.empty();
+}
+
 
 template<class CharType, class CharTraits,
     class DomainT, class BitSetT,

Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -60,7 +60,7 @@
 void MapGentorT<MapTV>::some(MapTV& x)
 {
     NumberGentorT<int> intGentor;
- x.clear();
+ ITL_FUN_CALL(clear, x);
     m_sample.clear();
     m_sampleSize = intGentor(m_sampleSizeRange);
 

Modified: sandbox/itl/boost/itl_xt/setgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/setgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/setgentor.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -81,7 +81,7 @@
 void SetGentorT<SetTV>::some(SetTV& x)
 {
     NumberGentorT<int> intGentor;
- x.clear();
+ ITL_FUN_CALL(clear, x);
     m_sample.clear();
     m_sampleSize = intGentor(m_sampleSizeRange);
 

Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -108,7 +108,7 @@
             if(_info_level >= inform::rarely)
                 reportFrequencies();
 
- return _violationsCount.empty();
+ return itl::is_empty(_violationsCount);
         }
 
         void validateType()
@@ -162,7 +162,7 @@
                     avg_evaluation_time_per_law, " total avg of atomic evaluation (micro sec)", instance_count, avg_evaluation_time_per_law);
 
             int violation_count = 1;
- if(!_violations.empty())
+ if(!itl::is_empty(_violations))
             {
                 std::cout << "------------------------------------------------------------------------------" << std::endl;
                 std::cout << "--- Law violations -----------------------------------------------count-------" << std::endl;
@@ -172,14 +172,14 @@
                 printf("%3d %-59s%8d\n", violation_count, it->first.c_str(), it->second.getViolationsCount());
                 violation_count++;
             }
- if(!_violations.empty())
+ if(!itl::is_empty(_violations))
                 std::cout << "------------------------------------------------------------------------------" << std::endl;
             ITL_FORALL(ViolationMapT, it, _violations)
             {
                 PolyLawViolations violas = it->second;
                 violas.reportFirst();
             }
- if(!_violations.empty())
+ if(!itl::is_empty(_violations))
                 std::cout << "------------------------------------------------------------------------------" << std::endl;
         }
 

Modified: sandbox/itl/boost/validate/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl/functors.hpp (original)
+++ sandbox/itl/boost/validate/itl/functors.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -26,7 +26,7 @@
 {
     void operator()(TargetT& collected, const SourceT& items)
     {
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
         ITL_const_FORALL(typename SourceT, item_, items)
             collected.insert(*item_);
     }
@@ -40,7 +40,7 @@
 {
     void operator()(TargetT& collected, const SourceT& items)
     {
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
         typename TargetT::iterator prior_ = collected.end();
         ITL_const_FORALL(typename SourceT, item_, items)
             prior_ = collected.insert(prior_, *item_);
@@ -55,7 +55,7 @@
 {
     void operator()(TargetT& collected, const SourceT& items)
     {
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
         std::copy(items.begin(), items.end(), itl::inserter(collected, collected.end()));
     }
 };
@@ -69,7 +69,7 @@
 {
     void operator()(TargetT& collected, const SourceT& items)
     {
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
         ITL_const_FORALL(typename SourceT, item_, items)
             collected.add(*item_);
     }
@@ -83,7 +83,7 @@
 {
     void operator()(TargetT& collected, const SourceT& items)
     {
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
         typename TargetT::iterator prior_ = collected.end();
         ITL_const_FORALL(typename SourceT, item_, items)
             prior_ = collected.add(prior_, *item_);
@@ -98,7 +98,7 @@
 {
     void operator()(TargetT& collected, const SourceT& items)
     {
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
         std::copy(items.begin(), items.end(), itl::adder(collected, collected.end()));
     }
 };

Modified: sandbox/itl/boost/validate/laws/law_violations.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/law_violations.hpp (original)
+++ sandbox/itl/boost/validate/laws/law_violations.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -146,8 +146,8 @@
         iterator end() { return _violations.end(); }
         const_iterator end()const { return _violations.begin(); }
 
- void clear() { _violations.clear(); }
- bool empty()const { return _violations.empty(); }
+ void clear() { ITL_FUN_CALL(clear, _violations); }
+ bool empty()const { return ITL_FUN_REN(empty, is_empty, _violations); }
         size_type size()const { return _violations.size(); }
 
         void reportFirst()const

Modified: sandbox/itl/boost/validate/validater/law_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/law_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/law_validater.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -136,9 +136,9 @@
     template <class LawT, template<typename>class GentorT>
     void LawValidater<LawT, GentorT>::init()
     {
- _frequencies.clear();
+ ITL_FUN_CALL(clear, _frequencies);
         _lawViolations.clear();
- _violations.clear();
+ ITL_FUN_CALL(clear, _violations);
     }
 
     // Runs law_instance_count * repeat_count validations on the law LawT

Modified: sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -113,7 +113,7 @@
         rightopen_interval<ptime> when = it->first;
         // Who is at the party within the time interval 'when' ?
         GuestSetT who = (*it++).second;
- cout << when << ": " << who << endl;
+ cout << when << ": " << who << endl;
     }
 
 }

Modified: sandbox/itl/libs/itl/example/interval_/interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_/interval.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_/interval.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -35,16 +35,16 @@
     cout << "----------------------------------------------------\n";
 
     discrete_interval<int> int_interval
- = construct<discrete_interval<int> >(3, 7, interval_bounds::closed());
+ = construct<discrete_interval<int> >(3, 7, interval_bounds::closed());
     continuous_interval<double> sqrt_interval
- = construct<continuous_interval<double> >(1/sqrt(2.0), sqrt(2.0));
- //interval_bounds::right_open() is default
+ = construct<continuous_interval<double> >(1/sqrt(2.0), sqrt(2.0));
+ //interval_bounds::right_open() is default
     continuous_interval<string> city_interval
- = construct<continuous_interval<string> >("Barcelona", "Boston", interval_bounds::left_open());
+ = construct<continuous_interval<string> >("Barcelona", "Boston", interval_bounds::left_open());
 
     discrete_interval<Time> time_interval
- = construct<discrete_interval<Time> >(Time(monday,8,30), Time(monday,17,20),
- interval_bounds::open());
+ = construct<discrete_interval<Time> >(Time(monday,8,30), Time(monday,17,20),
+ interval_bounds::open());
 
     cout << " discrete_interval<int>: " << int_interval << endl;
     cout << "continuous_interval<double>: " << sqrt_interval << " does "
@@ -58,7 +58,7 @@
                                             << " contain 'Berlin'" << endl;
     cout << " discrete_interval<Time>: " << time_interval << endl;
 
- return 0;
+ return 0;
 }
 
 // Program output:

Modified: sandbox/itl/libs/itl/example/man_power_/man_power.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/man_power_/man_power.cpp (original)
+++ sandbox/itl/libs/itl/example/man_power_/man_power.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -125,9 +125,9 @@
 
     // Bodos additional absence times
     discrete_interval<date> bodos_flu(from_string("2008-09-19"), from_string("2008-09-29"),
- interval_bounds::closed());
+ interval_bounds::closed());
     discrete_interval<date> bodos_vacation(from_string("2008-08-15"), from_string("2008-09-03"),
- interval_bounds::closed());
+ interval_bounds::closed());
 
     interval_set<date> bodos_absence_times(bodos_flu);
     bodos_absence_times += bodos_vacation;

Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -214,10 +214,17 @@
 
     */
 
- //int found;
- //TargetT::reverse_iterator it = std::find(left.rbegin(), left.rend(), found); //!
+ discrete_interval<int> fst = discrete_interval<int>::open(1,3);
+ discrete_interval<int> itv = discrete_interval<int>::rightopen(0,3);
 
- bool incl = std::includes(left.rbegin(), left.rend(), right.rbegin(), right.rend(), std::greater<int>());
+ cout << "fst = " << fst << endl;
+ cout << "itv = " << itv << endl;
+ discrete_interval<int> lft = right_subtract(fst,itv);
 
+ cout << "lft = " << lft << endl;
+ if(itl::is_empty(lft))
+ cout << "is MT\n";
+ else
+ cout << "is NOT MT\n";
 }
 

Modified: sandbox/itl/libs/itl/test/test_functions.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_functions.hpp (original)
+++ sandbox/itl/libs/itl/test/test_functions.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -13,6 +13,9 @@
 #define BOOST_ITL_TEST_FUNCTIONS_H_JOFA_091003
 
 #include <boost/itl/detail/notate.hpp>
+#include <boost/itl/type_traits/interval_type_of.hpp>
+#include <boost/itl/discrete_interval.hpp>
+
 #include <boost/itl/type_traits/neutron.hpp>
 #include <boost/itl/functors.hpp>
 

Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -32,8 +32,9 @@
 template <class T, class U>
 void interval_map_mixed_equal_4_ordered_types()
 {
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     T v0 = neutron<T>::value();
     U u1 = unon<U>::value();
@@ -78,6 +79,7 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     T v0 = neutron<T>::value();
     T v1 = unon<T>::value();
@@ -110,6 +112,8 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     T v1 = make<T>(1);
     T v2 = make<T>(2);
@@ -118,13 +122,13 @@
     T v5 = make<T>(5);
 
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I4_5D_1(I4_5D, u1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
 
     SplitIntervalMapT split_map;
     split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
@@ -138,6 +142,8 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v1 = make<T>(1);
@@ -146,13 +152,13 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I4_5D_1(I4_5D, u1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
 
     SplitIntervalMapT split_map;
     split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
@@ -168,6 +174,8 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v1 = make<T>(1);
@@ -176,13 +184,13 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I4_5D_1(I4_5D, u1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
 
     IntervalMapT join_map;
     join_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
@@ -205,6 +213,8 @@
 void partial_interval_map_mixed_inclusion_compare_4_bicremental_types()
 {
     typedef interval_map<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     //--------------------------------------------------------------------------
     // equalities
     // { 0 1 2 3 4 5 8 9 }
@@ -325,6 +335,7 @@
 void partial_interval_map_mixed_contains_4_bicremental_types()
 {
     typedef interval_map<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     //--------------------------------------------------------------------------
     // { 0 1 2 3 4 5 8 9 }
     // {[0,2)[2,3](3,6) (7,9]}
@@ -451,8 +462,9 @@
 template <class T, class U>
 void interval_map_mixed_add_4_bicremental_types()
 {
- typedef interval_map<T,U> IntervalMapT;
- typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
+ typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     U u1 = make<U>(1);
 
     T v1 = make<T>(1);
@@ -461,13 +473,13 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I4_5D_1(I4_5D, u1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
     mapping_pair<T,U> v1_1(v1, u1);
     mapping_pair<T,U> v3_1(v3, u1);
     mapping_pair<T,U> v5_1(v5, u1);
@@ -494,6 +506,8 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v1 = make<T>(1);
@@ -502,13 +516,13 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I4_5D_1(I4_5D, u1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
     mapping_pair<T,U> v1_1(v1, u1);
     mapping_pair<T,U> v3_1(v3, u1);
     mapping_pair<T,U> v5_1(v5, u1);
@@ -534,8 +548,10 @@
 template <class T, class U>
 void interval_map_mixed_subtract_4_bicremental_types()
 {
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v0 = make<T>(0);
@@ -548,21 +564,21 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
 
     SplitIntervalMapT split_map;
     split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
@@ -618,6 +634,8 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v0 = make<T>(0);
@@ -630,21 +648,21 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
 
     SplitIntervalMapT split_map;
     split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
@@ -698,10 +716,12 @@
 template <class T, class U>
 void interval_map_mixed_erase2_4_bicremental_types()
 {
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
- typedef interval_set<T> IntervalSetT;
- typedef split_interval_set<T> SplitIntervalSetT;
+ typedef interval_set<T> IntervalSetT;
+ typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v0 = make<T>(0);
@@ -714,21 +734,21 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
 
     SplitIntervalMapT split_map;
     split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
@@ -808,8 +828,10 @@
 template <class T, class U>
 void interval_map_mixed_insert_erase_4_bicremental_types()
 {
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v0 = make<T>(0);
@@ -822,21 +844,21 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
 
     SplitIntervalMapT split_A, split_B, split_all, split_X;
     IntervalMapT join_A, join_B, join_all, join_X;
@@ -901,8 +923,10 @@
 {
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
- typedef interval_set<T> IntervalSetT;
+ typedef interval_set<T> IntervalSetT;
     typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
 
     T v0 = make<T>(0);
@@ -915,21 +939,21 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
 
     SplitIntervalMapT split_A, split_B, split_all, split_X;
     IntervalMapT join_A, join_B, join_all, join_X;
@@ -1003,6 +1027,8 @@
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef interval_set<T> IntervalSetT;
     typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     U u2 = make<U>(2);
     U u3 = make<U>(3);
@@ -1018,27 +1044,27 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I1_8D_1(I1_8D, u1);
- std::pair<const interval<T>,U> I2_7D_1(I2_7D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_3(I2_3D, u3);
- std::pair<interval<T>,U> I6_7D_1(I6_7D, u1);
- std::pair<interval<T>,U> I6_7D_3(I6_7D, u3);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I1_8D_1(I1_8D, u1);
+ std::pair<const IntervalT,U> I2_7D_1(I2_7D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_3(I2_3D, u3);
+ std::pair<IntervalT,U> I6_7D_1(I6_7D, u1);
+ std::pair<IntervalT,U> I6_7D_3(I6_7D, u3);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
 
     //--------------------------------------------------------------------------
     // split_interval_map
@@ -1086,9 +1112,9 @@
 
     split_AB = split_A;
     split_AB &= mapping_pair<T,U>(v1,u1);
- split_AB += make_pair(interval<T>::open(v1,v7), u2);
+ split_AB += make_pair(IntervalT::open(v1,v7), u2);
     split_ab2.clear();
- split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u2);
+ split_ab2 += make_pair(IntervalT::rightopen(v1,v7), u2);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 }
@@ -1101,6 +1127,8 @@
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef interval_set<T> IntervalSetT;
     typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     U u2 = make<U>(2);
     U u3 = make<U>(3);
@@ -1116,27 +1144,27 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I1_8D_1(I1_8D, u1);
- std::pair<interval<T>,U> I2_7D_1(I2_7D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_3(I2_3D, u3);
- std::pair<interval<T>,U> I6_7D_1(I6_7D, u1);
- std::pair<interval<T>,U> I6_7D_3(I6_7D, u3);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I1_8D_1(I1_8D, u1);
+ std::pair<IntervalT,U> I2_7D_1(I2_7D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_3(I2_3D, u3);
+ std::pair<IntervalT,U> I6_7D_1(I6_7D, u1);
+ std::pair<IntervalT,U> I6_7D_3(I6_7D, u3);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
 
     //--------------------------------------------------------------------------
     // split_interval_map
@@ -1182,10 +1210,10 @@
     BOOST_CHECK_EQUAL( split_AB, split_ab );
 
     split_AB = split_A;
- split_AB &= interval<T>(v1);
- split_AB += make_pair(interval<T>::open(v1,v7), u1);
+ split_AB &= IntervalT(v1);
+ split_AB += make_pair(IntervalT::open(v1,v7), u1);
     split_ab2.clear();
- split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u1);
+ split_ab2 += make_pair(IntervalT::rightopen(v1,v7), u1);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 
@@ -1208,7 +1236,9 @@
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef interval_set<T> IntervalSetT;
- typedef split_interval_set<T> SplitIntervalSetT;
+ typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     U u2 = make<U>(2);
 
@@ -1224,27 +1254,27 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_2D = interval<T>::rightopen(v1,v2);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_2D_1(I1_2D, u1);
- std::pair<interval<T>,U> I1_2D_2(I1_2D, u2);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_2(I2_3D, u2);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I5_8D_1(I5_8D, u1);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_2D = IntervalT::rightopen(v1,v2);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
+ std::pair<IntervalT,U> I1_2D_2(I1_2D, u2);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_2(I2_3D, u2);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I5_8D_1(I5_8D, u1);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
 
     //--------------------------------------------------------------------------
     // split_interval_set
@@ -1286,10 +1316,12 @@
 template <class T, class U>
 void interval_map_mixed_intersect2_4_bicremental_types()
 {
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;
- typedef interval_set<T> IntervalSetT;
- typedef split_interval_set<T> SplitIntervalSetT;
+ typedef interval_set<T> IntervalSetT;
+ typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     U u2 = make<U>(2);
 
@@ -1305,27 +1337,27 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_2D = interval<T>::rightopen(v1,v2);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_2D_1(I1_2D, u1);
- std::pair<interval<T>,U> I1_2D_2(I1_2D, u2);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_2(I2_3D, u2);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I5_8D_1(I5_8D, u1);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_2D = IntervalT::rightopen(v1,v2);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
+ std::pair<IntervalT,U> I1_2D_2(I1_2D, u2);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_2(I2_3D, u2);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I5_8D_1(I5_8D, u1);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
 
     //--------------------------------------------------------------------------
     // split_interval_set
@@ -1370,6 +1402,8 @@
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef interval_set<T> IntervalSetT;
     typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     T v0 = make<T>(0);
     T v2 = make<T>(2);
@@ -1377,19 +1411,19 @@
     T v4 = make<T>(4);
     T v6 = make<T>(6);
 
- interval<T> I0_2D = interval<T>::rightopen(v0,v2);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I3_4D = interval<T>::rightopen(v3,v4);
- interval<T> I4_4I = interval<T>::closed(v4,v4);
- interval<T> C4_6D = interval<T>::open(v4,v6);
- interval<T> I6_6I = interval<T>::closed(v6,v6);
-
- std::pair<interval<T>,U> I0_2D_1(I0_2D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I3_4D_1(I3_4D, u1);
- std::pair<interval<T>,U> I4_4I_1(I4_4I, u1);
- std::pair<interval<T>,U> C4_6D_1(C4_6D, u1);
- std::pair<interval<T>,U> I6_6I_1(I6_6I, u1);
+ IntervalT I0_2D = IntervalT::rightopen(v0,v2);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I4_4I = IntervalT::closed(v4,v4);
+ IntervalT C4_6D = IntervalT::open(v4,v6);
+ IntervalT I6_6I = IntervalT::closed(v6,v6);
+
+ std::pair<IntervalT,U> I0_2D_1(I0_2D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I3_4D_1(I3_4D, u1);
+ std::pair<IntervalT,U> I4_4I_1(I4_4I, u1);
+ std::pair<IntervalT,U> C4_6D_1(C4_6D, u1);
+ std::pair<IntervalT,U> I6_6I_1(I6_6I, u1);
 
     //--------------------------------------------------------------------------
     //split_A: [0 2) [4 4] [6 6]
@@ -1413,7 +1447,7 @@
 {
     bool operator()(const Type& value)const
     {
- return value.first.size() > 1 ;
+ return itl::size(value.first) > 1 ;
     }
 };
 
@@ -1425,6 +1459,8 @@
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef interval_set<T> IntervalSetT;
     typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     U u1 = make<U>(1);
     T v0 = make<T>(0);
     T v2 = make<T>(2);
@@ -1432,19 +1468,19 @@
     T v4 = make<T>(4);
     T v6 = make<T>(6);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I3_4D = interval<T>::rightopen(v3,v4);
- interval<T> I4_4I = interval<T>::closed(v4,v4);
- interval<T> C4_6D = interval<T>::open(v4,v6);
- interval<T> I6_6I = interval<T>::closed(v6,v6);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I3_4D_1(I3_4D, u1);
- std::pair<interval<T>,U> I4_4I_1(I4_4I, u1);
- std::pair<interval<T>,U> C4_6D_1(C4_6D, u1);
- std::pair<interval<T>,U> I6_6I_1(I6_6I, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I4_4I = IntervalT::closed(v4,v4);
+ IntervalT C4_6D = IntervalT::open(v4,v6);
+ IntervalT I6_6I = IntervalT::closed(v6,v6);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I3_4D_1(I3_4D, u1);
+ std::pair<IntervalT,U> I4_4I_1(I4_4I, u1);
+ std::pair<IntervalT,U> C4_6D_1(C4_6D, u1);
+ std::pair<IntervalT,U> I6_6I_1(I6_6I, u1);
 
     //--------------------------------------------------------------------------
     //split_A: [0 2) [4 4] [6 6]
@@ -1467,6 +1503,8 @@
 void interval_map_mixed_infix_plus_overload_4_bicremental_types()
 {
     typedef interval_map<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
     interval_map<T,U> join_a;
     split_interval_map<T,U> split_a;
 

Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -20,6 +20,7 @@
 void interval_map_fundamentals_4_ordered_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMapT::size_type size_T;
     typedef typename IntervalMapT::difference_type diff_T;
 
@@ -32,9 +33,9 @@
     //T v1 = unon<T>();
     T v0 = neutron<T>::value();
     T v1 = unon<T>::value();
- interval<T> I0_0I(v0);
- interval<T> I1_1I(v1);
- interval<T> I0_1I(v0,v1);
+ IntervalT I0_0I(v0);
+ IntervalT I1_1I(v1);
+ IntervalT I0_1I(v0, v1, interval_bounds::closed());
     U u1 = unon<U>::value();
 
     //-------------------------------------------------------------------------
@@ -47,8 +48,8 @@
     BOOST_CHECK_EQUAL(IntervalMapT().iterative_size(), 0);
     BOOST_CHECK_EQUAL(IntervalMapT(), IntervalMapT());
 
- interval<T> mt_interval = neutron<interval<T> >::value();
- BOOST_CHECK_EQUAL(mt_interval, interval<T>());
+ IntervalT mt_interval = neutron<IntervalT >::value();
+ BOOST_CHECK_EQUAL(mt_interval, IntervalT());
     typename IntervalMapT::value_type mt_u1 = make_pair(mt_interval, u1);
     IntervalMapT mt_map = neutron<IntervalMapT >::value();
     BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
@@ -60,7 +61,7 @@
     BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
     (mt_map += mt_u1) += mt_u1;
     BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
- BOOST_CHECK_EQUAL(hull(mt_map), neutron<interval<T> >::value());
+ BOOST_CHECK_EQUAL(hull(mt_map), neutron<IntervalT >::value());
 
     //subtracting emptieness
     mt_map.subtract(mt_u1).subtract(mt_u1);
@@ -169,10 +170,11 @@
 void interval_map_ctor_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     T v4 = make<T>(4);
     U u2 = make<U>(2);
- interval<T> I4_4I(v4);
+ IntervalT I4_4I(v4);
     typename IntervalMapT::domain_mapping_type v4_u2(v4,u2);
     typename IntervalMapT::value_type I4_4I_u2(I4_4I,u2);
 
@@ -232,20 +234,21 @@
 void interval_map_add_sub_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     T v0 = make<T>(0);
     T v5 = make<T>(5);
     T v6 = make<T>(6);
     T v9 = make<T>(9);
     U u1 = make<U>(1);
- interval<T> I5_6I(v5,v6);
- interval<T> I5_9I(v5,v9);
- interval<T> I0_9I = interval<T>::closed(v0, v9);
+ IntervalT I5_6I(v5,v6, interval_bounds::closed());
+ IntervalT I5_9I(v5,v9, interval_bounds::closed());
+ IntervalT I0_9I = IntervalT::closed(v0, v9);
     typename IntervalMapT::domain_mapping_type v0_u1 = make_pair(v0, u1);
     typename IntervalMapT::domain_mapping_type v9_u1 = make_pair(v9, u1);
     typename IntervalMapT::value_type I5_6I_u1 = make_pair(I5_6I, u1);
     typename IntervalMapT::value_type I5_9I_u1 = make_pair(I5_9I, u1);
- typename IntervalMapT::value_type I0_9I_u1 = make_pair(interval<T>::closed(v0, v9), u1);
+ typename IntervalMapT::value_type I0_9I_u1 = make_pair(IntervalT::closed(v0, v9), u1);
 
     BOOST_CHECK_EQUAL( IntervalMapT(I5_6I_u1).add(v0_u1).add(v9_u1),
                        IntervalMapT().add(v9_u1).add(I5_6I_u1).add(v0_u1) );
@@ -285,6 +288,7 @@
 void interval_map_distinct_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMap<T,U>::size_type size_T;
     typedef typename IntervalMap<T,U>::difference_type diff_T;
     T v1 = make<T>(1);
@@ -318,6 +322,7 @@
 void interval_map_distinct_4_bicremental_continuous_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMapT::size_type size_T;
     typedef typename IntervalMapT::difference_type diff_T;
     T v1 = make<T>(1);
@@ -346,10 +351,10 @@
     IntervalMapT is_123_5;
     is_123_5 = is_1_3_5;
     //OPROM: open problem: Ambiguity resolving value_type and mapping_type for overloaded o= operators.
- //is_123_5 += make_pair(interval<T>::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
- //is_123_5 += make_pair<interval<T>, U>(interval<T>::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
+ //is_123_5 += make_pair(IntervalT::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
+ //is_123_5 += make_pair<IntervalT, U>(IntervalT::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
     //USASO: unsatisfctory solution 1: explicit IntervalMapT::value_type instead of make_pair
- is_123_5 += typename IntervalMapT::value_type(interval<T>::open(v1,v3),u1);
+ is_123_5 += typename IntervalMapT::value_type(IntervalT::open(v1,v3),u1);
     //USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
 
     BOOST_CHECK_EQUAL( is_123_5.cardinality(), itl::infinity<size_T>::value() );
@@ -370,6 +375,7 @@
 void interval_map_isolate_4_bicremental_continuous_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMapT::size_type size_T;
     typedef typename IntervalMapT::difference_type diff_T;
 
@@ -377,9 +383,9 @@
     T v2 = make<T>(2);
     T v4 = make<T>(4);
     U u1 = make<U>(1);
- interval<T> I0_4I = interval<T>::closed(v0,v4);
- interval<T> C0_2D = interval<T>::open(v0,v2);
- interval<T> C2_4D = interval<T>::open(v2,v4);
+ IntervalT I0_4I = IntervalT::closed(v0,v4);
+ IntervalT C0_2D = IntervalT::open(v0,v2);
+ IntervalT C2_4D = IntervalT::open(v2,v4);
     typename IntervalMapT::value_type I0_4I_u1(I0_4I,u1);
     typename IntervalMapT::value_type C0_2D_u1(C0_2D,u1);
     typename IntervalMapT::value_type C2_4D_u1(C2_4D,u1);
@@ -423,6 +429,7 @@
 void interval_map_contains_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMapT::set_type IntervalSetT;
     IntervalMapT itv_map; itv_map.add(K_v(3,1));
     BOOST_CHECK_EQUAL( itv_map.contains(MK_v(3)), true );
@@ -465,6 +472,7 @@
 void interval_map_contains_key_objects_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMapT::set_type IntervalSetT;
     IntervalMapT itv_map;
 
@@ -505,6 +513,7 @@
 void interval_map_operators_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     T v0 = make<T>(0);
     T v1 = make<T>(1);
     T v3 = make<T>(3);
@@ -512,10 +521,10 @@
     T v7 = make<T>(7);
     T v8 = make<T>(8);
     U u1 = make<U>(1);
- typename IntervalMapT::interval_type I3_5I(interval<T>::closed(v3,v5));
- typename IntervalMapT::value_type I0_1I_u1(interval<T>::closed(v0,v1),u1);
- typename IntervalMapT::value_type I3_5I_u1(interval<T>::closed(v3,v5),u1);
- typename IntervalMapT::value_type I7_8I_u1(interval<T>::closed(v7,v8),u1);
+ typename IntervalMapT::interval_type I3_5I(IntervalT::closed(v3,v5));
+ typename IntervalMapT::value_type I0_1I_u1(IntervalT::closed(v0,v1),u1);
+ typename IntervalMapT::value_type I3_5I_u1(IntervalT::closed(v3,v5),u1);
+ typename IntervalMapT::value_type I7_8I_u1(IntervalT::closed(v7,v8),u1);
     
     IntervalMapT left, left2, right, all, section, complement;
     left.add(I0_1I_u1).add(I3_5I_u1);
@@ -547,6 +556,7 @@
 void interval_map_base_intersect_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     T v0 = make<T>(0);
     T v1 = make<T>(1);
@@ -561,16 +571,16 @@
 
     U u1 = make<U>(1);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_4D = interval<T>::rightopen(v1,v4);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_4D = IntervalT::rightopen(v1,v4);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
 
     typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
     typename IntervalMapT::value_type I6_9D_1(I6_9D, u1);
@@ -653,6 +663,7 @@
 void interval_map_base_erase_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     T v0 = make<T>(0);
     T v1 = make<T>(1);
@@ -667,22 +678,22 @@
 
     U u1 = make<U>(1);
 
- interval<T> I0_1D = interval<T>::rightopen(v0,v1);
- interval<T> I0_2D = interval<T>::rightopen(v0,v2);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_4D = interval<T>::rightopen(v1,v4);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
- interval<T> I7_9D = interval<T>::rightopen(v7,v9);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
+ IntervalT I0_1D = IntervalT::rightopen(v0,v1);
+ IntervalT I0_2D = IntervalT::rightopen(v0,v2);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_4D = IntervalT::rightopen(v1,v4);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+ IntervalT I7_9D = IntervalT::rightopen(v7,v9);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
 
     typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
     typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
@@ -770,6 +781,7 @@
 void interval_map_base_is_disjoint_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMap<T,U>::interval_set_type IntervalSetT;
 
     T v0 = make<T>(0);
@@ -783,12 +795,12 @@
 
     U u1 = make<U>(1);
 
- interval<T> I0_1D = interval<T>::rightopen(v0,v1);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
+ IntervalT I0_1D = IntervalT::rightopen(v0,v1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
 
     typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
     typename IntervalMapT::value_type I1_3D_1(I1_3D, u1);
@@ -854,6 +866,7 @@
 void interval_map_flip_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef IntervalMapT IMap;
 
     IntervalMapT set_a;
@@ -865,6 +878,7 @@
     // 1 1
     //BOOST_CHECK_EQUAL(IMap(IDv(0,2,1)) ^= (IDv(1,3,1)), IMap(IDv(0,1,1)) + IDv(2,3,1));
     set_a = IMap(IDv(0,2,1));
+ IntervalMapT set_b = set_a;
     BOOST_CHECK_EQUAL(set_a ^= IDv(1,3,1), IMap(IDv(0,1,1)) + IDv(2,3,1));
 }
 
@@ -880,8 +894,9 @@
 void interval_map_infix_plus_overload_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
     IntervalMapT map_a, map_b;
@@ -907,8 +922,9 @@
 void interval_map_infix_pipe_overload_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
     IntervalMapT map_a, map_b;
@@ -936,12 +952,13 @@
 void interval_map_infix_minus_overload_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
- itl::interval<T> itv = C_D(4,11);
+ IntervalT itv = C_D(4,11);
     typename IntervalMapT::interval_mapping_type itv_v = CDv(4,11,3);
 
     IntervalMapT map_a, map_b, map_c;
@@ -988,12 +1005,13 @@
 void interval_map_infix_et_overload_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
- itl::interval<T> itv = C_D(4,11);
+ IntervalT itv = C_D(4,11);
 
     IntervalMapT map_a, map_b;
     map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
@@ -1037,12 +1055,13 @@
 void interval_map_infix_caret_overload_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
- itl::interval<T> itv = C_D(4,11);
+ IntervalT itv = C_D(4,11);
 
     IntervalMapT map_a, map_b;
     map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
@@ -1076,9 +1095,10 @@
 void interval_map_find_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
     IntervalMapT map_a;
@@ -1108,9 +1128,10 @@
 void interval_map_set_4_bicremental_types()
 {
     typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
     mapping_pair<T,U> map_pair = K_v(4,3);
 
     IntervalMapT map_a;
@@ -1135,6 +1156,7 @@
 void interval_map_inclusion_compare_4_bicremental_types()
 {
     typedef IntervalMap<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMap<T,U,Trt>::set_type IntervalSetT;
     typedef itl::map<T,U,Trt> MapT;
     typedef itl::set<T> SetT;
@@ -1206,9 +1228,10 @@
 void interval_map_std_copy_via_inserter_4_bicremental_types()
 {
     typedef IntervalMap<T,U,Trt> IntervalMapT; //Nedded for the test value generator
+ typedef typename IntervalMapT::interval_type IntervalT;
 
     // Check equality of copying using handcoded loop or std::copy via inserter.
- typedef std::pair<interval<T>, U> SegmentT;
+ typedef std::pair<IntervalT, U> SegmentT;
     std::vector<SegmentT> seg_vec_a;
     IntervalMapT std_copied_map;
 
@@ -1247,6 +1270,7 @@
 void interval_map_element_iter_4_discrete_types()
 {
     typedef IntervalMap<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
     typedef typename IntervalMapT::element_iterator ReptatorT;
     typedef std::vector<std::pair<T,U> > VectorT;
 

Modified: sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -11,6 +11,9 @@
 template <class T>
 void interval_set_mixed_ctor_4_ordered_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = neutron<T>::value();
     
     split_interval_set<T> split_set(v0);
@@ -24,6 +27,9 @@
 template <class T>
 void interval_set_mixed_equal_4_ordered_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = neutron<T>::value();
     
     split_interval_set<T> split_empty, split_single(v0);
@@ -88,6 +94,9 @@
 template <class T>
 void interval_set_mixed_assign_4_ordered_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = neutron<T>::value();
     T v1 = unon<T>::value();
 
@@ -117,15 +126,18 @@
 template <class T>
 void interval_set_mixed_ctor_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v1 = make<T>(1);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
 
     split_interval_set<T> split_set;
     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -147,15 +159,18 @@
 template <class T>
 void interval_set_mixed_assign_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v1 = make<T>(1);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
 
     split_interval_set<T> split_set;
     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -182,15 +197,18 @@
 template <class T>
 void interval_set_mixed_equal_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v1 = make<T>(1);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
 
     interval_set<T> join_set;
     join_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -222,6 +240,9 @@
 template <class T>
 void interval_set_mixed_contains_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     split_interval_set<T> split_set;
     split_set.add(I_D(0,4)).add(I_D(4,8));
     BOOST_CHECK_EQUAL( split_set.contains(MK_v(4)), true );
@@ -239,15 +260,18 @@
 template <class T>
 void interval_set_mixed_add_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v1 = make<T>(1);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
 
     split_interval_set<T> split_set;
     split_set.add(I1_3D).add(I2_4D);
@@ -286,6 +310,9 @@
 template <class T>
 void interval_set_mixed_subtract_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = make<T>(0);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
@@ -296,13 +323,13 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     split_interval_set<T> split_set;
     split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
@@ -394,6 +421,9 @@
 template <class T>
 void interval_set_mixed_erase_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = make<T>(0);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
@@ -404,13 +434,13 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     split_interval_set<T> split_set;
     split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
@@ -501,6 +531,9 @@
 template <class T>
 void interval_set_mixed_basic_intersect_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = make<T>(0);
     T v1 = make<T>(1);
     T v2 = make<T>(2);
@@ -510,14 +543,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
 
     //--------------------------------------------------------------------------
     // split_interval_set
@@ -558,9 +591,9 @@
     BOOST_CHECK_EQUAL( split_AB, split_ab );
 
     split_AB = split_A;
- (split_AB &= v1) += interval<T>::open(v1,v7);
+ (split_AB &= v1) += IntervalT::open(v1,v7);
     split_ab2.clear();
- split_ab2 += interval<T>::rightopen(v1,v7);
+ split_ab2 += IntervalT::rightopen(v1,v7);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 }
@@ -568,6 +601,9 @@
 template <class T>
 void interval_set_mixed_intersect_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = make<T>(0);
     T v1 = make<T>(1);
     T v2 = make<T>(2);
@@ -579,14 +615,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_2D = interval<T>::rightopen(v1,v2);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_2D = IntervalT::rightopen(v1,v2);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
 
     //--------------------------------------------------------------------------
     // split_interval_set
@@ -702,18 +738,21 @@
 template <class T>
 void interval_set_mixed_disjoint_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = make<T>(0);
     T v2 = make<T>(2);
     T v3 = make<T>(3);
     T v4 = make<T>(4);
     T v6 = make<T>(6);
    
- interval<T> I0_2D = interval<T>::rightopen(v0,v2);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I3_4D = interval<T>::rightopen(v3,v4);
- interval<T> I4_4I = interval<T>::closed(v4,v4);
- interval<T> C4_6D = interval<T>::open(v4,v6);
- interval<T> I6_6I = interval<T>::closed(v6,v6);
+ IntervalT I0_2D = IntervalT::rightopen(v0,v2);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I4_4I = IntervalT::closed(v4,v4);
+ IntervalT C4_6D = IntervalT::open(v4,v6);
+ IntervalT I6_6I = IntervalT::closed(v6,v6);
 
     //--------------------------------------------------------------------------
     //split_A: [0 2) [4 4] [6 6]
@@ -742,6 +781,9 @@
 template <class T>
 void interval_set_mixed_infix_plus_overload_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     interval_set<T> join_a;
     separate_interval_set<T> sep_a;
     split_interval_set<T> split_a;
@@ -757,6 +799,9 @@
 
 template <class T> void interval_set_mixed_infix_pipe_overload_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     interval_set<T> join_a;
     separate_interval_set<T> sep_a;
     split_interval_set<T> split_a;
@@ -773,6 +818,9 @@
 template <class T>
 void interval_set_mixed_infix_minus_overload_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     interval_set<T> join_a, join_b;
     separate_interval_set<T> sep_a, sep_b;
     split_interval_set<T> split_a, split_b;
@@ -792,6 +840,9 @@
 
 template <class T> void interval_set_mixed_infix_et_overload_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     interval_set<T> join_a;
     separate_interval_set<T> sep_a;
     split_interval_set<T> split_a;
@@ -807,6 +858,9 @@
 
 template <class T> void interval_set_mixed_infix_caret_overload_4_bicremental_types()
 {
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     interval_set<T> join_a;
     separate_interval_set<T> sep_a;
     split_interval_set<T> split_a;

Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -17,6 +17,8 @@
           class T>
 void interval_set_fundamentals_4_ordered_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef typename IntervalSet<T>::size_type size_T;
     typedef typename IntervalSet<T>::difference_type diff_T;
 
@@ -27,9 +29,9 @@
 
     T v0 = neutron<T>::value();
     T v1 = unon<T>::value();
- interval<T> I0_0I(v0);
- interval<T> I1_1I(v1);
- interval<T> I0_1I(v0,v1);
+ IntervalT I0_0I(v0);
+ IntervalT I1_1I(v1);
+ IntervalT I0_1I(v0, v1, interval_bounds::closed());
 
     //-------------------------------------------------------------------------
     //empty set
@@ -41,8 +43,8 @@
     BOOST_CHECK_EQUAL(IntervalSet<T>().iterative_size(), 0);
     BOOST_CHECK_EQUAL(IntervalSet<T>(), IntervalSet<T>());
 
- interval<T> mt_interval = neutron<interval<T> >::value();
- BOOST_CHECK_EQUAL(mt_interval, interval<T>());
+ IntervalT mt_interval = neutron<IntervalT >::value();
+ BOOST_CHECK_EQUAL(mt_interval, IntervalT());
     IntervalSet<T> mt_set = neutron<IntervalSet<T> >::value();
     BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
 
@@ -53,7 +55,7 @@
     BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
     (mt_set += mt_interval) += mt_interval;
     BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
- BOOST_CHECK_EQUAL(hull(mt_set), neutron<interval<T> >::value());
+ BOOST_CHECK_EQUAL(hull(mt_set), neutron<IntervalT >::value());
 
     //subtracting emptieness
     mt_set.subtract(mt_interval).subtract(mt_interval);
@@ -148,8 +150,11 @@
           class T>
 void interval_set_ctor_4_bicremental_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v4 = make<T>(4);
- interval<T> I4_4I(v4);
+ IntervalT I4_4I(v4);
 
     IntervalSet<T> _I4_4I;
     BOOST_CHECK_EQUAL( _I4_4I.empty(), true );
@@ -199,13 +204,16 @@
           class T>
 void interval_set_add_sub_4_bicremental_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
     T v0 = make<T>(0);
     T v5 = make<T>(5);
     T v6 = make<T>(6);
     T v9 = make<T>(9);
- interval<T> I5_6I(v5,v6);
- interval<T> I5_9I(v5,v9);
- interval<T> I0_9I = interval<T>::closed(v0, v9);
+ IntervalT I5_6I(v5,v6,interval_bounds::closed());
+ IntervalT I5_9I(v5,v9,interval_bounds::closed());
+ IntervalT I0_9I = IntervalT::closed(v0, v9);
 
     BOOST_CHECK_EQUAL( IntervalSet<T>(I5_6I).add(v0).add(v9),
                        IntervalSet<T>().insert(v9).insert(I5_6I).insert(v0) );
@@ -240,6 +248,8 @@
           class T>
 void interval_set_distinct_4_bicremental_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef typename IntervalSet<T>::size_type size_T;
     typedef typename IntervalSet<T>::difference_type diff_T;
     T v1 = make<T>(1);
@@ -267,6 +277,8 @@
           class T>
 void interval_set_distinct_4_bicremental_continuous_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef typename IntervalSet<T>::size_type size_T;
     typedef typename IntervalSet<T>::difference_type diff_T;
     T v1 = make<T>(1);
@@ -290,7 +302,7 @@
 
     IntervalSet<T> is_123_5;
     is_123_5 = is_1_3_5;
- is_123_5 += interval<T>::open(v1,v3);
+ is_123_5 += IntervalT::open(v1,v3);
 
     BOOST_CHECK_EQUAL( is_123_5.cardinality(), itl::infinity<size_T>::value() );
     BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
@@ -306,15 +318,17 @@
           class T>
 void interval_set_isolate_4_bicremental_continuous_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef typename IntervalSet<T>::size_type size_T;
     typedef typename IntervalSet<T>::difference_type diff_T;
 
     T v0 = make<T>(0);
     T v2 = make<T>(2);
     T v4 = make<T>(4);
- interval<T> I0_4I = interval<T>::closed(v0,v4);
- interval<T> C0_2D = interval<T>::open(v0,v2);
- interval<T> C2_4D = interval<T>::open(v2,v4);
+ IntervalT I0_4I = IntervalT::closed(v0,v4);
+ IntervalT C0_2D = IntervalT::open(v0,v2);
+ IntervalT C2_4D = IntervalT::open(v2,v4);
     // {[0 4]}
     // - { (0,2) (2,4) }
     // = {[0] [2] [4]}
@@ -352,6 +366,7 @@
 void interval_set_element_compare_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef IntervalSet<T> ISet;
 
     BOOST_CHECK_EQUAL( is_element_equal( ISet(), ISet()), true );
@@ -396,6 +411,8 @@
           class T>
 void interval_set_contains_4_bicremental_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     //LAW: x.add(e).contains(e);
     //LAW: z = x + y => z.contains(x) && z.contains(y);
     T v1 = make<T>(1);
@@ -410,17 +427,17 @@
 
     BOOST_CHECK_EQUAL( IntervalSet<T>().add(make<T>(2)).contains(make<T>(2)), true );
     BOOST_CHECK_EQUAL( IntervalSet<T>().insert(make<T>(2)).contains(make<T>(2)), true );
- BOOST_CHECK_EQUAL( (is += interval<T>(v3,v7)).contains(interval<T>(v3,v7)), true );
+ BOOST_CHECK_EQUAL( (is += IntervalT(v3,v7)).contains(IntervalT(v3,v7)), true );
 
     IntervalSet<T> is0 = is;
 
- IntervalSet<T> is2(interval<T>::closed(v5,v8));
+ IntervalSet<T> is2(IntervalT::closed(v5,v8));
     is2.add(v9).add(v11);
     is += is2;
     BOOST_CHECK_EQUAL( is.contains(is2), true );
 
     is = is0;
- IntervalSet<T> is3(interval<T>::closed(v5,v8));
+ IntervalSet<T> is3(IntervalT::closed(v5,v8));
     is3.insert(v9).insert(v11);
     is += is3;
     BOOST_CHECK_EQUAL( is.contains(is3), true );
@@ -435,6 +452,8 @@
           class T>
 void interval_set_operators_4_bicremental_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     T v0 = make<T>(0);
     T v1 = make<T>(1);
     T v3 = make<T>(3);
@@ -442,8 +461,8 @@
     T v7 = make<T>(7);
     T v8 = make<T>(8);
     IntervalSet<T> left, left2, right, all, all2, section, complement, naught;
- left.add(interval<T>::closed(v0,v1)).add(interval<T>::closed(v3,v5));
- (right += interval<T>::closed(v3,v5)) += interval<T>::closed(v7,v8);
+ left.add(IntervalT::closed(v0,v1)).add(IntervalT::closed(v3,v5));
+ (right += IntervalT::closed(v3,v5)) += IntervalT::closed(v7,v8);
 
     BOOST_CHECK_EQUAL( is_disjoint(left, right), false );
 
@@ -479,6 +498,8 @@
           class T>
 void interval_set_base_intersect_4_bicremental_types()
 {
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     T v0 = make<T>(0);
     T v1 = make<T>(1);
     T v2 = make<T>(2);
@@ -488,14 +509,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
 
     //--------------------------------------------------------------------------
     // IntervalSet
@@ -536,9 +557,9 @@
     BOOST_CHECK_EQUAL( split_AB, split_ab );
 
     split_AB = split_A;
- (split_AB &= v1) += interval<T>::open(v1,v7);
+ (split_AB &= v1) += IntervalT::open(v1,v7);
     split_ab2.clear();
- split_ab2 += interval<T>::rightopen(v1,v7);
+ split_ab2 += IntervalT::rightopen(v1,v7);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 }
@@ -553,6 +574,7 @@
 void interval_set_flip_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef IntervalSetT ISet;
 
     IntervalSetT set_a, set_b, lhs, rhs;
@@ -592,7 +614,8 @@
 void interval_set_infix_plus_overload_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+ IntervalT itv = I_D(3,5);
 
     IntervalSetT set_a, set_b;
     set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -614,7 +637,9 @@
 void interval_set_infix_pipe_overload_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
 
     IntervalSetT set_a, set_b;
     set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -637,7 +662,9 @@
 void interval_set_infix_minus_overload_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
 
     IntervalSetT set_a, set_b;
     set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -659,7 +686,9 @@
 void interval_set_infix_et_overload_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
 
     IntervalSetT set_a, set_b;
     set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -682,7 +711,9 @@
 void interval_set_infix_caret_overload_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
 
     IntervalSetT set_a, set_b;
     set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -705,7 +736,9 @@
 void interval_set_find_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
 
     IntervalSetT set_a;
     set_a.add(C_D(1,3)).add(I_I(6,11));
@@ -728,6 +761,7 @@
 void interval_set_element_iter_4_discrete_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef std::vector<T> VectorT;
 
     IntervalSetT set_a;

Modified: sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -22,6 +22,7 @@
 void interval_set_check_monoid_plus_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
 
     IntervalSetT set_a, set_b, set_c;
     set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -45,6 +46,7 @@
 void interval_set_check_monoid_et_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
 
     IntervalSetT set_a, set_b, set_c;
     set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -72,6 +74,7 @@
 void interval_set_check_abelian_monoid_plus_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
 
     IntervalSetT set_a, set_b, set_c;
     set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -95,6 +98,7 @@
 void interval_set_check_abelian_monoid_et_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
 
     IntervalSetT set_a, set_b, set_c;
     set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -122,6 +126,7 @@
 void interval_set_check_partial_invertive_monoid_plus_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
 
     IntervalSetT set_a, set_b, set_c;
     set_a.add(I_D(3,6)).add(I_I(5,7));

Modified: sandbox/itl/libs/itl/test/test_set_itl_set.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_itl_set.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_itl_set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -22,6 +22,7 @@
 void itl_set_check_monoid_plus_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef itl::set<T> SetT;
 
     IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -52,6 +53,7 @@
 void itl_set_check_monoid_et_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef itl::set<T> SetT;
 
     IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -85,6 +87,7 @@
 void itl_set_check_abelian_monoid_plus_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef itl::set<T> SetT;
 
     IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -114,6 +117,7 @@
 void itl_set_check_abelian_monoid_et_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef itl::set<T> SetT;
 
     IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -147,6 +151,7 @@
 void itl_set_check_partial_invertive_monoid_plus_4_bicremental_types()
 {
     typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
     typedef itl::set<T> SetT;
 
     IntervalSetT itv_set_a, itv_set_b, itv_set_c;

Modified: sandbox/itl/libs/itl/test/test_value_maker.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_value_maker.hpp (original)
+++ sandbox/itl/libs/itl/test/test_value_maker.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -83,10 +83,11 @@
     typedef typename ItvMapT::domain_mapping_type domain_mapping_type;
     typedef std::pair<domain_type, codomain_type> std_pair_type;
 
- static interval<domain_type> interval_(int lower, int upper, int bounds = 2)
+ static interval_type interval_(int lower, int upper, int bounds = 2)
     {
         return interval_type(test_value<domain_type>::make(lower),
- test_value<domain_type>::make(upper), static_cast<bound_type>(bounds));
+ test_value<domain_type>::make(upper), interval_bounds(bounds));
+ //CL test_value<domain_type>::make(upper), static_cast<bound_type>(bounds));
     }
 
     static value_type val_pair(int lower, int upper, int val, int bounds = 2)
@@ -111,13 +112,13 @@
 // Very short value denotation for intervals
 // Assumption typename T existes in scope
 //I_I : [a,b]
-#define I_I(low,up) itl::interval<T>::closed (make<T>(low), make<T>(up))
+#define I_I(low,up) IntervalT::closed (make<T>(low), make<T>(up))
 //I_D : [a,b)
-#define I_D(low,up) itl::interval<T>::rightopen(make<T>(low), make<T>(up))
+#define I_D(low,up) IntervalT::rightopen(make<T>(low), make<T>(up))
 //C_I : (a,b]
-#define C_I(low,up) itl::interval<T>::leftopen (make<T>(low), make<T>(up))
+#define C_I(low,up) IntervalT::leftopen (make<T>(low), make<T>(up))
 //C_D : (a,b)
-#define C_D(low,up) itl::interval<T>::open (make<T>(low), make<T>(up))
+#define C_D(low,up) IntervalT::open (make<T>(low), make<T>(up))
 
 #define MK_v(key) make<T>(key)
 #define MK_u(key) make<U>(key)

Modified: sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp (original)
+++ sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -21,7 +21,7 @@
 
 int main()
 {
- typedef InplaceCommutativity<itl::list<int> > TestLawT;
+ typedef InplaceCommutativity<itl::list<int> > TestLawT;
     LawValidater<TestLawT> law_validator;
 
     //-----------------------------------------------------------------------------

Modified: sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj
==============================================================================
--- sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj (original)
+++ sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -239,6 +239,10 @@
>
                 </Filter>
                 <File
+ RelativePath=".\ClassDiagram1.cd"
+ >
+ </File>
+ <File
                         RelativePath=".\ReadMe.txt"
>
                 </File>

Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -75,15 +75,15 @@
     //LawValidater<TestLawT> test_law;
 
 
-
- typedef FunctionEquality
- <
- itl::list<std::pair<rightopen_interval<double,std::less>,int> >, //SourceT,
- split_interval_map<double,int,partial_absorber>, //TargetT,
- base_insertion,
- hint_insertion
- >
- TestLawT;
+
+ typedef FunctionEquality
+ <
+ itl::list<std::pair<rightopen_interval<double,std::less>,int> >, //SourceT,
+ split_interval_map<double,int,partial_absorber>, //TargetT,
+ base_insertion,
+ hint_insertion
+ >
+ TestLawT;
     LawValidater<TestLawT> test_law;
 
 


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