Boost logo

Boost-Commit :

Date view Thread view Subject view Author view

Subject: [Boost-commit] svn:boost r65830 - in sandbox/itl: boost/itl boost/itl/concept boost/itl/detail boost/itl/type_traits boost/itl_xt boost/validate/gentor libs/itl/example/boost_party_ libs/itl/example/custom_interval_ libs/itl/example/interval_container_ libs/itl/example/large_bitset_ libs/itl/example/man_power_ libs/itl/example/month_and_week_grid_ libs/itl/example/overlap_counter_ libs/itl/example/party_ libs/itl/example/partys_height_average_ libs/itl/example/partys_tallest_guests_ libs/itl/example/std_copy_ libs/itl/test libs/itl/test/fastest_itl_interval_ libs/itl/test/test_casual_ libs/itl/test/test_itl_interval_ libs/itl_xt/example/history_ libs/itl_xt/test/meta_functors_ libs/validate/example/labat_polygon_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2010-10-08 12:19:20

Author: jofaber
Date: 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
New Revision: 65830
URL: http://svn.boost.org/trac/boost/changeset/65830

Log:
Refactoring: Renaming leftopen/rightopen to left_open/right_open. Stable{msvc-9.0,10.0, gcc-3.4.4}
Text files modified:
   sandbox/itl/boost/itl/concept/interval.hpp | 42 +++------
   sandbox/itl/boost/itl/continuous_interval.hpp | 4
   sandbox/itl/boost/itl/detail/design_config.hpp | 2
   sandbox/itl/boost/itl/discrete_interval.hpp | 4
   sandbox/itl/boost/itl/interval.hpp | 16 +-
   sandbox/itl/boost/itl/interval_bounds.hpp | 12 +-
   sandbox/itl/boost/itl/leftopen_interval.hpp | 26 +++---
   sandbox/itl/boost/itl/rightopen_interval.hpp | 26 +++---
   sandbox/itl/boost/itl/type_traits/interval_type_default.hpp | 4
   sandbox/itl/boost/itl/type_traits/is_interval.hpp | 16 +-
   sandbox/itl/boost/itl_xt/interval_bitset.hpp | 12 +-
   sandbox/itl/boost/itl_xt/itvgentor.hpp | 2
   sandbox/itl/boost/itl_xt/mapgentor.hpp | 2
   sandbox/itl/boost/itl_xt/numbergentor.hpp | 8
   sandbox/itl/boost/itl_xt/seqgentor.hpp | 2
   sandbox/itl/boost/itl_xt/setgentor.hpp | 2
   sandbox/itl/boost/itl_xt/typed_episode.hpp | 2
   sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 16 +-
   sandbox/itl/boost/validate/gentor/randomgentor.hpp | 10 +-
   sandbox/itl/boost/validate/gentor/rangegentor.hpp | 10 +-
   sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp | 10 +-
   sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp | 4
   sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp | 10 +-
   sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp | 4
   sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp | 8
   sandbox/itl/libs/itl/example/man_power_/man_power.cpp | 4
   sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp | 6
   sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp | 6
   sandbox/itl/libs/itl/example/party_/party.cpp | 6
   sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp | 10 +-
   sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp | 12 +-
   sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp | 6
   sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp | 24 ++--
   sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 2
   sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp | 4
   sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp | 4
   sandbox/itl/libs/itl/test/test_icl_interval.hpp | 2
   sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 170 ++++++++++++++++++++--------------------
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 64 +++++++-------
   sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp | 88 ++++++++++----------
   sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 18 ++--
   sandbox/itl/libs/itl/test/test_itl_interval.hpp | 92 ++++++++++----------
   sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp | 24 ++--
   sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp | 34 ++++----
   sandbox/itl/libs/itl/test/test_value_maker.hpp | 8
   sandbox/itl/libs/itl_xt/example/history_/history.cpp | 10 +-
   sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp | 26 +++---
   sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp | 6
   sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp | 4
   sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 2
   50 files changed, 437 insertions(+), 449 deletions(-)

Modified: sandbox/itl/boost/itl/concept/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -15,7 +15,7 @@
 #include <boost/mpl/not.hpp>
 #include <boost/detail/is_incrementable.hpp>
 #include <boost/itl/detail/design_config.hpp>
-#include <boost/itl/type_traits/given.hpp>
+//CL #include <boost/itl/type_traits/given.hpp> //JODO given unused: remove
 #include <boost/itl/type_traits/unit_element.hpp>
 #include <boost/itl/type_traits/identity_element.hpp>
 #include <boost/itl/type_traits/infinity.hpp>
@@ -70,7 +70,7 @@
 template<class Type>
 typename enable_if
 <
- mpl::and_< is_static_rightopen<Type>
+ mpl::and_< is_static_right_open<Type>
              , is_discrete<typename interval_traits<Type>::domain_type> >
   , Type
>::type
@@ -83,7 +83,7 @@
 template<class Type>
 typename enable_if
 <
- mpl::and_< is_static_leftopen<Type>
+ mpl::and_< is_static_left_open<Type>
              , is_discrete<typename interval_traits<Type>::domain_type> >
   , Type
>::type
@@ -129,22 +129,10 @@
 typename enable_if<has_static_bounds<Type>, Type>::type
 construct(const typename interval_traits<Type>::domain_type& low,
           const typename interval_traits<Type>::domain_type& up )
-//CL interval_bounds bounds = interval_bounds::right_open())
 {
     return interval_traits<Type>::construct(low, up);
 }
 
-/*CL
-template<class Type>
-typename enable_if<has_symmetric_bounds<Type>, Type>::type
-construct(const typename interval_traits<Type>::domain_type& low,
- const typename interval_traits<Type>::domain_type& up,
- interval_bounds bounds = interval_bounds::right_open())
-{
- return interval_traits<Type>::construct(low, up);
-}
-*/
-
 template<class Type>
 typename enable_if<has_dynamic_bounds<Type>, Type>::type
 construct(const typename interval_traits<Type>::domain_type& low,
@@ -178,7 +166,7 @@
 
 //==============================================================================
 template<class Type>
-typename enable_if<is_static_rightopen<Type>, Type>::type
+typename enable_if<is_static_right_open<Type>, Type>::type
 hull(const typename interval_traits<Type>::domain_type& left,
      const typename interval_traits<Type>::domain_type& right)
 {
@@ -189,7 +177,7 @@
 }
 
 template<class Type>
-typename enable_if<is_static_leftopen<Type>, Type>::type
+typename enable_if<is_static_left_open<Type>, Type>::type
 hull(const typename interval_traits<Type>::domain_type& left,
      const typename interval_traits<Type>::domain_type& right)
 {
@@ -270,7 +258,7 @@
 //- first ----------------------------------------------------------------------
 template<class Type>
 inline typename
-enable_if< mpl::or_<is_static_rightopen<Type>, is_static_closed<Type> >
+enable_if< mpl::or_<is_static_right_open<Type>, is_static_closed<Type> >
          , typename interval_traits<Type>::domain_type>::type
 first(const Type& object)
 {
@@ -279,7 +267,7 @@
 
 template<class Type>
 inline typename
-enable_if< mpl::and_< mpl::or_<is_static_leftopen<Type>, is_static_open<Type> >
+enable_if< mpl::and_< mpl::or_<is_static_left_open<Type>, is_static_open<Type> >
                     , is_discrete<typename interval_traits<Type>::domain_type> >
          , typename interval_traits<Type>::domain_type>::type
 first(const Type& object)
@@ -300,7 +288,7 @@
 //- last -----------------------------------------------------------------------
 template<class Type>
 inline typename
-enable_if< mpl::or_<is_static_leftopen<Type>, is_static_closed<Type> >
+enable_if< mpl::or_<is_static_left_open<Type>, is_static_closed<Type> >
          , typename interval_traits<Type>::domain_type>::type
 last(const Type& object)
 {
@@ -309,7 +297,7 @@
 
 template<class Type>
 inline typename
-enable_if< mpl::and_< mpl::or_<is_static_rightopen<Type>, is_static_open<Type> >
+enable_if< mpl::and_< mpl::or_<is_static_right_open<Type>, is_static_open<Type> >
                     , is_discrete<typename interval_traits<Type>::domain_type> >
          , typename interval_traits<Type>::domain_type>::type
 last(const Type& object)
@@ -336,7 +324,7 @@
 //- last_next ------------------------------------------------------------------
 template<class Type>
 inline typename
-enable_if< mpl::and_< mpl::or_<is_static_leftopen<Type>, is_static_closed<Type> >
+enable_if< mpl::and_< mpl::or_<is_static_left_open<Type>, is_static_closed<Type> >
                     , is_discrete<typename interval_traits<Type>::domain_type> >
          , typename interval_traits<Type>::domain_type>::type
 last_next(const Type& object)
@@ -346,7 +334,7 @@
 
 template<class Type>
 inline typename
-enable_if< mpl::and_< mpl::or_<is_static_rightopen<Type>, is_static_open<Type> >
+enable_if< mpl::and_< mpl::or_<is_static_right_open<Type>, is_static_open<Type> >
                     , is_discrete<typename interval_traits<Type>::domain_type> >
          , typename interval_traits<Type>::domain_type>::type
 last_next(const Type& object)
@@ -1314,13 +1302,13 @@
 //==============================================================================
 template<class Type>
 typename boost::
- enable_if< mpl::or_< is_static_leftopen<Type>
+ enable_if< mpl::or_< is_static_left_open<Type>
                        , is_static_open<Type> >, std::string>::type
 left_bracket(const Type&) { return "("; }
 
 template<class Type>
 typename boost::
- enable_if< mpl::or_< is_static_rightopen<Type>
+ enable_if< mpl::or_< is_static_right_open<Type>
                        , is_static_closed<Type> >, std::string>::type
 left_bracket(const Type&) { return "["; }
 
@@ -1334,13 +1322,13 @@
 //------------------------------------------------------------------------------
 template<class Type>
 typename boost::
- enable_if< mpl::or_< is_static_rightopen<Type>
+ enable_if< mpl::or_< is_static_right_open<Type>
                        , is_static_open<Type> >, std::string>::type
 right_bracket(const Type&) { return ")"; }
 
 template<class Type>
 typename boost::
- enable_if< mpl::or_< is_static_leftopen<Type>
+ enable_if< mpl::or_< is_static_left_open<Type>
                        , is_static_closed<Type> >, std::string>::type
 right_bracket(const Type&) { return "]"; }
 

Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -73,8 +73,8 @@
     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 right_open(const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::right_open());}
+ static continuous_interval left_open (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:

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -19,7 +19,7 @@
 // implementation for intervals.
 #define ITL_NEW_INTERVAL_IMPL //JODO remove for the final release.
 
-// If this macro is defined, rightopen_interval with static interval borders
+// If this macro is defined, right_open_interval with static interval borders
 // 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

Modified: sandbox/itl/boost/itl/discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/discrete_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -72,8 +72,8 @@
     interval_bounds bounds()const{ return _bounds; }
 
     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 right_open(const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::right_open());}
+ static discrete_interval left_open (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:

Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -58,11 +58,11 @@
 // { return type(low, up, interval_bounds::closed()); }
 //
 // /** Rightopen interval <tt>[low,up)</tt> */
-// static type rightopen(const DomainT& low, const DomainT& up)
+// static type right_open(const DomainT& low, const DomainT& up)
 // { return type(low, up, interval_bounds::right_open); }
 //
 // /** Leftopen interval <tt>(low,up]</tt> */
-// static type leftopen(const DomainT& low, const DomainT& up)
+// static type left_open(const DomainT& low, const DomainT& up)
 // { return type(low, up, interval_bounds::left_open); }
 //
 // /** Open interval <tt>(low,up)</tt> */
@@ -91,9 +91,9 @@
     /// Both open: <tt>(x,y)</tt>
     open_bounded = 0, // '00'
     /// Left open right closed: <tt>(x,y]</tt>
- left_open = 1, // '01'
+ left_open_bounded = 1, // '01'
     /// Left closed right open: <tt>[x,y)</tt>
- right_open = 2, // '10'
+ right_open_bounded = 2, // '10'
     /// Both closed: <tt>[x,y]</tt>
     closed_bounded = 3 // '11'
 } ;
@@ -177,12 +177,12 @@
     { return interval(low, up, itl::closed_bounded); }
 
     /** Rightopen interval <tt>[low,up)</tt> */
- static interval rightopen(const DomainT& low, const DomainT& up)
- { return interval(low, up, right_open); }
+ static interval right_open(const DomainT& low, const DomainT& up)
+ { return interval(low, up, itl::right_open_bounded); }
 
     /** Leftopen interval <tt>(low,up]</tt> */
- static interval leftopen(const DomainT& low, const DomainT& up)
- { return interval(low, up, left_open); }
+ static interval left_open(const DomainT& low, const DomainT& up)
+ { return interval(low, up, itl::left_open_bounded); }
 
     /** Open interval <tt>(low,up)</tt> */
     static interval open(const DomainT& low, const DomainT& up)

Modified: sandbox/itl/boost/itl/interval_bounds.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_bounds.hpp (original)
+++ sandbox/itl/boost/itl/interval_bounds.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -20,15 +20,15 @@
 {
 public:
     BOOST_STATIC_CONSTANT(bound_type, static_open = 0);
- BOOST_STATIC_CONSTANT(bound_type, static_leftopen = 1);
- BOOST_STATIC_CONSTANT(bound_type, static_rightopen = 2);
+ BOOST_STATIC_CONSTANT(bound_type, static_left_open = 1);
+ BOOST_STATIC_CONSTANT(bound_type, static_right_open = 2);
     BOOST_STATIC_CONSTANT(bound_type, static_closed = 3);
     BOOST_STATIC_CONSTANT(bound_type, dynamic = 4);
     BOOST_STATIC_CONSTANT(bound_type, undefined = 5);
 
     BOOST_STATIC_CONSTANT(bound_type, _open = 0);
- BOOST_STATIC_CONSTANT(bound_type, _leftopen = 1);
- BOOST_STATIC_CONSTANT(bound_type, _rightopen = 2);
+ BOOST_STATIC_CONSTANT(bound_type, _left_open = 1);
+ BOOST_STATIC_CONSTANT(bound_type, _right_open = 2);
     BOOST_STATIC_CONSTANT(bound_type, _closed = 3);
 
     BOOST_STATIC_CONSTANT(bound_type, _right = 1);
@@ -47,8 +47,8 @@
     bound_type bits()const{ return _bits; }
 
     static interval_bounds open() { return interval_bounds(_open); }
- static interval_bounds left_open() { return interval_bounds(_leftopen); }
- static interval_bounds right_open(){ return interval_bounds(_rightopen);}
+ static interval_bounds left_open() { return interval_bounds(_left_open); }
+ static interval_bounds right_open(){ return interval_bounds(_right_open);}
     static interval_bounds closed() { return interval_bounds(_closed); }
 
 public:

Modified: sandbox/itl/boost/itl/leftopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/leftopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/leftopen_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -19,10 +19,10 @@
 
 template <class DomainT,
           ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class leftopen_interval
+class left_open_interval
 {
 public:
- typedef leftopen_interval<DomainT,Compare> type;
+ typedef left_open_interval<DomainT,Compare> type;
     typedef DomainT domain_type;
 
 public:
@@ -30,7 +30,7 @@
     //= Construct, copy, destruct
     //==========================================================================
     /** Default constructor; yields an empty interval <tt>(0,0]</tt>. */
- leftopen_interval()
+ left_open_interval()
         : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -40,7 +40,7 @@
     //NOTE: Compiler generated copy constructor is used
 
     /** Constructor for a left-open singleton interval <tt>(val-1,val]</tt> */
- explicit leftopen_interval(const DomainT& val)
+ explicit left_open_interval(const DomainT& val)
         : _lwb(pred(val)), _upb(val)
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -52,7 +52,7 @@
     }
 
     /** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
- leftopen_interval(const DomainT& low, const DomainT& up) :
+ left_open_interval(const DomainT& low, const DomainT& up) :
         _lwb(low), _upb(up)
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -68,14 +68,14 @@
 };
 
 //==============================================================================
-//=T leftopen_interval -> concept intervals
+//=T left_open_interval -> concept intervals
 //==============================================================================
 template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::leftopen_interval<DomainT, Compare> >
+struct interval_traits< itl::left_open_interval<DomainT, Compare> >
 {
     typedef DomainT domain_type;
     typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::leftopen_interval<DomainT, Compare> interval_type;
+ typedef itl::left_open_interval<DomainT, Compare> interval_type;
 
     static interval_type construct(const domain_type& lo, const domain_type& up)
     {
@@ -91,23 +91,23 @@
 //= Type traits
 //==============================================================================
 template <class DomainT, ITL_COMPARE Compare>
-struct interval_bound_type< leftopen_interval<DomainT,Compare> >
+struct interval_bound_type< left_open_interval<DomainT,Compare> >
 {
     typedef interval_bound_type type;
- BOOST_STATIC_CONSTANT(unsigned char, value = interval_bounds::static_leftopen);
+ BOOST_STATIC_CONSTANT(unsigned char, value = interval_bounds::static_left_open);
 };
 
 template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::leftopen_interval<DomainT,Compare> >
+struct type_to_string<itl::left_open_interval<DomainT,Compare> >
 {
     static std::string apply()
     { return "(I]<"+ type_to_string<DomainT>::apply() +">"; }
 };
 
 template<class DomainT, ITL_COMPARE Compare>
-struct value_size<itl::leftopen_interval<DomainT,Compare> >
+struct value_size<itl::left_open_interval<DomainT,Compare> >
 {
- static std::size_t apply(const itl::leftopen_interval<DomainT>& value)
+ static std::size_t apply(const itl::left_open_interval<DomainT>& value)
     { return 2; }
 };
 

Modified: sandbox/itl/boost/itl/rightopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/rightopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/rightopen_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -19,10 +19,10 @@
 
 template <class DomainT,
           ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class rightopen_interval
+class right_open_interval
 {
 public:
- typedef rightopen_interval<DomainT,Compare> type;
+ typedef right_open_interval<DomainT,Compare> type;
     typedef DomainT domain_type;
 
 public:
@@ -30,7 +30,7 @@
     //= Construct, copy, destruct
     //==========================================================================
     /** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
- rightopen_interval()
+ right_open_interval()
         : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -40,7 +40,7 @@
     //NOTE: Compiler generated copy constructor is used
 
     /** Constructor for a singleton interval <tt>[val,val+1)</tt> */
- explicit rightopen_interval(const DomainT& val)
+ explicit right_open_interval(const DomainT& val)
         : _lwb(val), _upb(succ(val))
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -51,7 +51,7 @@
     }
 
     /** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
- rightopen_interval(const DomainT& low, const DomainT& up) :
+ right_open_interval(const DomainT& low, const DomainT& up) :
         _lwb(low), _upb(up)
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -67,14 +67,14 @@
 };
 
 //==============================================================================
-//=T rightopen_interval -> concept intervals
+//=T right_open_interval -> concept intervals
 //==============================================================================
 template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::rightopen_interval<DomainT, Compare> >
+struct interval_traits< itl::right_open_interval<DomainT, Compare> >
 {
     typedef DomainT domain_type;
     typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::rightopen_interval<DomainT, Compare> interval_type;
+ typedef itl::right_open_interval<DomainT, Compare> interval_type;
 
     static interval_type construct(const domain_type& lo, const domain_type& up)
     {
@@ -90,23 +90,23 @@
 //= Type traits
 //==============================================================================
 template <class DomainT, ITL_COMPARE Compare>
-struct interval_bound_type< rightopen_interval<DomainT,Compare> >
+struct interval_bound_type< right_open_interval<DomainT,Compare> >
 {
     typedef interval_bound_type type;
- BOOST_STATIC_CONSTANT(unsigned char, value = interval_bounds::static_rightopen);
+ BOOST_STATIC_CONSTANT(unsigned char, value = interval_bounds::static_right_open);
 };
 
 template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::rightopen_interval<DomainT,Compare> >
+struct type_to_string<itl::right_open_interval<DomainT,Compare> >
 {
     static std::string apply()
     { return "[I)<"+ type_to_string<DomainT>::apply() +">"; }
 };
 
 template<class DomainT, ITL_COMPARE Compare>
-struct value_size<itl::rightopen_interval<DomainT,Compare> >
+struct value_size<itl::right_open_interval<DomainT,Compare> >
 {
- static std::size_t apply(const itl::rightopen_interval<DomainT>& value)
+ static std::size_t apply(const itl::right_open_interval<DomainT>& value)
     { return 2; }
 };
 

Modified: sandbox/itl/boost/itl/type_traits/interval_type_default.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/interval_type_default.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/interval_type_default.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -27,8 +27,8 @@
 #ifdef ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
         typedef
             typename mpl::if_< is_discrete<DomainT>
- , rightopen_interval<DomainT,Compare>
- , rightopen_interval<DomainT,Compare> >::type type;
+ , right_open_interval<DomainT,Compare>
+ , right_open_interval<DomainT,Compare> >::type type;
 #else
         typedef
             typename mpl::if_< is_discrete<DomainT>

Modified: sandbox/itl/boost/itl/type_traits/is_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -48,8 +48,8 @@
     typedef has_asymmetric_bounds<Type> type;
     BOOST_STATIC_CONSTANT(unsigned char, bounds = (interval_bound_type<Type>::value));
     BOOST_STATIC_CONSTANT(bool,
- value = ( bounds == interval_bounds::static_leftopen
- || bounds == interval_bounds::static_rightopen));
+ value = ( bounds == interval_bounds::static_left_open
+ || bounds == interval_bounds::static_right_open));
 };
 
 template <class Type> struct has_symmetric_bounds
@@ -72,18 +72,18 @@
 };
 
 //------------------------------------------------------------------------------
-template <class Type> struct is_static_rightopen
+template <class Type> struct is_static_right_open
 {
- typedef is_static_rightopen<Type> type;
+ typedef is_static_right_open<Type> type;
     BOOST_STATIC_CONSTANT(bool,
- value = (interval_bound_type<Type>::value == interval_bounds::static_rightopen));
+ value = (interval_bound_type<Type>::value == interval_bounds::static_right_open));
 };
 
-template <class Type> struct is_static_leftopen
+template <class Type> struct is_static_left_open
 {
- typedef is_static_leftopen<Type> type;
+ typedef is_static_left_open<Type> type;
     BOOST_STATIC_CONSTANT(bool,
- value = (interval_bound_type<Type>::value == interval_bounds::static_leftopen));
+ value = (interval_bound_type<Type>::value == interval_bounds::static_left_open));
 };
 
 template <class Type> struct is_static_open

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -43,7 +43,7 @@
     typename DomainT = unsigned long,
     typename BitSetT = itl::bits<unsigned long>,
     ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare), //JODO change to rightopen_interval
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare), //JODO change to right_open_interval
     ITL_ALLOC Alloc = std::allocator
>
 class interval_bitset
@@ -284,10 +284,10 @@
                      condensed_type& up, bitset_type& super,
                      const segment_type& segment)const;
 
- void add_(DomainT lo, DomainT up, BitSetT bits){_map += value_type(interval_type::rightopen(lo,up), bits);}
- void subtract_(DomainT lo, DomainT up, BitSetT bits){_map -= value_type(interval_type::rightopen(lo,up), bits);}
- void intersect_(DomainT lo, DomainT up, BitSetT bits){_map &= value_type(interval_type::rightopen(lo,up), bits);}
- void flip_(DomainT lo, DomainT up, BitSetT bits){_map ^= value_type(interval_type::rightopen(lo,up), bits);}
+ void add_(DomainT lo, DomainT up, BitSetT bits){_map += value_type(interval_type::right_open(lo,up), bits);}
+ void subtract_(DomainT lo, DomainT up, BitSetT bits){_map -= value_type(interval_type::right_open(lo,up), bits);}
+ void intersect_(DomainT lo, DomainT up, BitSetT bits){_map &= value_type(interval_type::right_open(lo,up), bits);}
+ void flip_(DomainT lo, DomainT up, BitSetT bits){_map ^= value_type(interval_type::right_open(lo,up), bits);}
 
 private:
     interval_bitmap_type _map;
@@ -366,7 +366,7 @@
             return false;
         if(parts.contains(super_part) && !_map(up).contains(supers))
             return false;
- if(parts.contains(inter_part) && !_map.contains(seg_type(interval_type::rightopen(lo,up), inters)) )
+ if(parts.contains(inter_part) && !_map.contains(seg_type(interval_type::right_open(lo,up), inters)) )
             return false;
 
         return true;

Modified: sandbox/itl/boost/itl_xt/itvgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/itvgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/itvgentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -52,7 +52,7 @@
     { m_valueRange = range; }
 
     void setValueRange(ItvDomTV low, ItvDomTV up)
- { m_valueRange.set(low,up, itl::right_open); }
+ { m_valueRange.set(low,up, itl::right_open_bounded); }
 
     void setMaxIntervalLength(ItvDomTV len) { m_maxIntervalLength=len; }
     void setProbDerivation();

Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -43,7 +43,7 @@
     }
 
     void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
+ { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
     void setRangeOfSampleSize(const interval<int>& szRange)
     { BOOST_ASSERT(szRange.is(right_open)); m_sampleSizeRange = szRange; }
 

Modified: sandbox/itl/boost/itl_xt/numbergentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/numbergentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/numbergentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -64,21 +64,21 @@
 {
 public:
     NumberGentorT():
- m_valueRange( NumTV(), unit_element<NumTV>::value(), right_open ) {}
+ m_valueRange( NumTV(), unit_element<NumTV>::value(), itl::right_open_bounded ) {}
 
     NumTV operator() (NumTV upb) { return rnd_0_to_excl<NumTV>(upb); }
     NumTV operator() (NumTV lwb, NumTV upb) { return rnd_within_exUpb<NumTV>(lwb,upb); }
     NumTV operator() (interval<NumTV> rng)
     {
- BOOST_ASSERT(rng.is(right_open) || rng.is(closed_bounded));
- if(rng.is(right_open))
+ BOOST_ASSERT(rng.is(right_open_bounded) || rng.is(closed_bounded));
+ if(rng.is(itl::right_open_bounded))
             return rnd_within_exUpb<NumTV>(rng.lower(), rng.upper());
         else
             return rnd_within<NumTV>(rng.lower(), rng.upper());
     }
 
     void setRange(interval<NumTV> rng) { m_valueRange = rng; }
- void setRange(NumTV lwb, NumTV upb) { m_valueRange = interval<NumTV>::rightopen(lwb,upb); }
+ void setRange(NumTV lwb, NumTV upb) { m_valueRange = interval<NumTV>::right_open(lwb,upb); }
 
     void calibrate(const RandomGentorProfile<NumTV>& profile)
     {

Modified: sandbox/itl/boost/itl_xt/seqgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/seqgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/seqgentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -60,7 +60,7 @@
     }
 
     void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
+ { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
     void setRangeOfSampleSize(const interval<int>& szRange)
     { BOOST_ASSERT(szRange.is(itl::right_open)); m_sampleSizeRange = szRange; }
 

Modified: sandbox/itl/boost/itl_xt/setgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/setgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/setgentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -63,7 +63,7 @@
     }
 
     void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
+ { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
     void setRangeOfSampleSize(const interval<int>& szRange)
     { BOOST_ASSERT(szRange.is(right_open)); m_sampleSizeRange = szRange; }
 

Modified: sandbox/itl/boost/itl_xt/typed_episode.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/typed_episode.hpp (original)
+++ sandbox/itl/boost/itl_xt/typed_episode.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -55,7 +55,7 @@
 
     /// das Intervall der Episode
     //virtual itl::interval<TimeT> interval()const=0; //JODO make IntervalT a template param
- virtual rightopen_interval<TimeT> interval()const=0;
+ virtual right_open_interval<TimeT> interval()const=0;
 };
 
 /// typed_episode is an episode that can be ordered wrt. it's type

Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -29,21 +29,21 @@
         void set_polygon_profile(int max_polygon_set_size, int max_polygon_size, int min_coord, int max_coord);
 
         void set_range_int(int lwb, int upb)
- { _range_int = interval<int>::rightopen(lwb, upb); }
+ { _range_int = interval<int>::right_open(lwb, upb); }
         void set_range_nat(cnat lwb, cnat upb)
- { _range_nat = interval<cnat>::rightopen(lwb, upb); }
+ { _range_nat = interval<cnat>::right_open(lwb, upb); }
         void set_range_double(double lwb, double upb)
- { _range_double = interval<double>::rightopen(lwb, upb); }
+ { _range_double = interval<double>::right_open(lwb, upb); }
         void set_range_ContainerSize(int lwb, int upb)
- { _range_ContainerSize = interval<int>::rightopen(lwb, upb); }
+ { _range_ContainerSize = interval<int>::right_open(lwb, upb); }
         void set_range_interval_int(int lwb, int upb)
- { _range_interval_int = interval<int>::rightopen(lwb, upb); }
+ { _range_interval_int = interval<int>::right_open(lwb, upb); }
         void set_range_interval_double(double lwb, double upb)
- { _range_interval_double = interval<double>::rightopen(lwb, upb); }
+ { _range_interval_double = interval<double>::right_open(lwb, upb); }
         void set_maxIntervalLength(int val)
         { _maxIntervalLength = val; }
         void set_range_codomain_ContainerSize(int lwb, int upb)
- { _range_codomain_ContainerSize = interval<int>::rightopen(lwb, upb); }
+ { _range_codomain_ContainerSize = interval<int>::right_open(lwb, upb); }
         void set_repeat_count(int repeat) { _repeat_count = repeat; }
         void set_trials_count(int trials) { _trials_count = trials; }
         void set_trials_count_release(int trials) { _trials_count_release = trials; }
@@ -169,7 +169,7 @@
         static interval<unsigned int> get()
         {
             interval<cnat> inter_val = GentorProfileSgl::it()->range_nat();
- return interval<unsigned int>::rightopen(inter_val.lower(), inter_val.upper());
+ return interval<unsigned int>::right_open(inter_val.lower(), inter_val.upper());
         }
     };
 

Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -276,7 +276,7 @@
         static void apply(RandomGentor<itl::bits<BitsT> >& gentor)
         {
             // Set the range within which the sizes of the generated object varies.
- gentor.set_range(itl::interval<BitsT>::rightopen(0, sizeof(BitsT)));
+ gentor.set_range(itl::interval<BitsT>::right_open(0, sizeof(BitsT)));
         }
     };
 
@@ -420,13 +420,13 @@
     };
 
     template <class NumericT, ITL_COMPARE Compare>
- struct Calibrater<itl::list< rightopen_interval<NumericT,Compare> >, RandomGentor>
+ struct Calibrater<itl::list< right_open_interval<NumericT,Compare> >, RandomGentor>
     {
- static void apply(RandomGentor< itl::list< rightopen_interval<NumericT,Compare> > >& gentor)
+ static void apply(RandomGentor< itl::list< right_open_interval<NumericT,Compare> > >& gentor)
         {
             gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
- ItvGentorT<NumericT, rightopen_interval<NumericT,Compare> >* itvGentor
- = new ItvGentorT<NumericT, rightopen_interval<NumericT,Compare> >;
+ ItvGentorT<NumericT, right_open_interval<NumericT,Compare> >* itvGentor
+ = new ItvGentorT<NumericT, right_open_interval<NumericT,Compare> >;
             itvGentor->setRange(GentorProfileSgl_numeric_range<NumericT>::get());
             itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
             gentor.setDomainGentor(itvGentor);

Modified: sandbox/itl/boost/validate/gentor/rangegentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/rangegentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/rangegentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -46,14 +46,14 @@
         interval<Type> last()const;
 
         void setLowerBoundRange(int lwb, int upb)
- { setLowerBoundRange(interval<int>::rightopen(lwb,upb)); }
+ { setLowerBoundRange(interval<int>::right_open(lwb,upb)); }
         void setLowerBoundRange(const interval<int>& range)
- { BOOST_ASSERT(range.is_rightopen()||range.is_closed()); _lwbGentor.setRange(range); }
+ { BOOST_ASSERT(range.is_right_open()||range.is_closed()); _lwbGentor.setRange(range); }
 
         void setUpperBoundRange(int lwb, int upb)
- { setUpperBoundRange(interval<int>::rightopen(lwb,upb)); }
+ { setUpperBoundRange(interval<int>::right_open(lwb,upb)); }
         void setUpperBoundRange(const interval<int>& range)
- { BOOST_ASSERT(range.is_rightopen()||range.is_closed()); _upbGentor.setRange(range); }
+ { BOOST_ASSERT(range.is_right_open()||range.is_closed()); _upbGentor.setRange(range); }
 
     private:
         NumberGentorT<Type> _lwbGentor;
@@ -67,7 +67,7 @@
         Type lwb, upb;
         _lwbGentor.some(lwb);
         _upbGentor.some(upb);
- _last = rightopen_interval(lwb, upb);
+ _last = right_open_interval(lwb, upb);
         x = _last;
     }
 

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -55,7 +55,7 @@
 
 // Prior to other includes for interval containers we define ...
 #define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
-// ... so all interval containers will use rightopen_intervals that
+// ... so all interval containers will use right_open_intervals that
 // have static interval borders.
 
 #include <boost/itl/interval_map.hpp>
@@ -87,21 +87,21 @@
 
     party.add( // add and element
       make_pair(
- rightopen_interval<ptime>(
+ right_open_interval<ptime>(
           time_from_string("2008-05-20 19:30"),
           time_from_string("2008-05-20 23:00")),
         mary_harry));
 
     party += // element addition can also be done via operator +=
       make_pair(
- rightopen_interval<ptime>(
+ right_open_interval<ptime>(
           time_from_string("2008-05-20 20:10"),
           time_from_string("2008-05-21 00:00")),
         diana_susan);
 
     party +=
       make_pair(
- rightopen_interval<ptime>(
+ right_open_interval<ptime>(
           time_from_string("2008-05-20 22:15"),
           time_from_string("2008-05-21 00:30")),
         peter);
@@ -111,7 +111,7 @@
     cout << "----- History of party guests -------------------------\n";
     while(it != party.end())
     {
- rightopen_interval<ptime> when = it->first;
+ right_open_interval<ptime> when = it->first;
         // Who is at the party within the time interval 'when' ?
         GuestSetT who = (*it++).second;
         cout << when << ": " << who << endl;

Modified: sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp (original)
+++ sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -59,8 +59,8 @@
 template<>
 struct interval_bound_type<MyInterval> //4. Finally we define the interval borders.
 { // Choose between static_open (lo..up)
- typedef interval_bound_type type; // static_leftopen (lo..up]
- BOOST_STATIC_CONSTANT(unsigned char, value = interval_bounds::static_rightopen);//[lo..up)
+ typedef interval_bound_type type; // static_left_open (lo..up]
+ BOOST_STATIC_CONSTANT(unsigned char, value = interval_bounds::static_right_open);//[lo..up)
 }; // and static_closed [lo..up]
 
 

Modified: sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -19,7 +19,7 @@
 
 // Prior to other includes for interval containers we define ...
 #define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
-// ... so all interval containers will use rightopen_intervals that
+// ... so all interval containers will use right_open_intervals that
 // have static interval borders.
 
 
@@ -34,10 +34,10 @@
 
 void interval_container_basics()
 {
- rightopen_interval<Time> night_and_day = rightopen_interval<Time>(Time(monday, 20,00), Time(tuesday, 20,00));
- rightopen_interval<Time> day_and_night = rightopen_interval<Time>(Time(tuesday, 7,00), Time(wednesday, 7,00));
- rightopen_interval<Time> next_morning = rightopen_interval<Time>(Time(wednesday, 7,00), Time(wednesday,10,00));
- rightopen_interval<Time> next_evening = rightopen_interval<Time>(Time(wednesday,18,00), Time(wednesday,21,00));
+ right_open_interval<Time> night_and_day = right_open_interval<Time>(Time(monday, 20,00), Time(tuesday, 20,00));
+ right_open_interval<Time> day_and_night = right_open_interval<Time>(Time(tuesday, 7,00), Time(wednesday, 7,00));
+ right_open_interval<Time> next_morning = right_open_interval<Time>(Time(wednesday, 7,00), Time(wednesday,10,00));
+ right_open_interval<Time> next_evening = right_open_interval<Time>(Time(wednesday,18,00), Time(wednesday,21,00));
 
     // An interval set of type interval_set joins intervals that that overlap or touch each other.
     interval_set<Time> joinedTimes;

Modified: sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -80,12 +80,12 @@
     cout << "--------------------------------------------\n";
 
     cout << "-- Flip bits in range [24,30) --------------\n";
- tall ^= discrete_interval<nat>::rightopen(24,30);
+ tall ^= discrete_interval<nat>::right_open(24,30);
     tall.show_segments();
     cout << "--------------------------------------------\n";
 
     cout << "-- Remove the first 10 bits ----------------\n";
- tall -= discrete_interval<nat>::rightopen(0,10);
+ tall -= discrete_interval<nat>::right_open(0,10);
     tall.show_segments();
 
     cout << "-- Remove even bits in range [0,72) --------\n";

Modified: sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -190,10 +190,10 @@
     //]
 
     //[large_bitmap_combiners
- void add_(DomainT lo, DomainT up, BitSetT bits){_map += value_type(interval_type::rightopen(lo,up), bits);}
- void subtract_(DomainT lo, DomainT up, BitSetT bits){_map -= value_type(interval_type::rightopen(lo,up), bits);}
- void intersect_(DomainT lo, DomainT up, BitSetT bits){_map &= value_type(interval_type::rightopen(lo,up), bits);}
- void flip_(DomainT lo, DomainT up, BitSetT bits){_map ^= value_type(interval_type::rightopen(lo,up), bits);}
+ void add_(DomainT lo, DomainT up, BitSetT bits){_map += value_type(interval_type::right_open(lo,up), bits);}
+ void subtract_(DomainT lo, DomainT up, BitSetT bits){_map -= value_type(interval_type::right_open(lo,up), bits);}
+ void intersect_(DomainT lo, DomainT up, BitSetT bits){_map &= value_type(interval_type::right_open(lo,up), bits);}
+ void flip_(DomainT lo, DomainT up, BitSetT bits){_map ^= value_type(interval_type::right_open(lo,up), bits);}
     //]
 
 //[large_bitmap_impl_map

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -50,7 +50,7 @@
     week_iterator week_iter(cur_weekend_sat);
 
     for(; week_iter <= last(scope); ++week_iter)
- weekends += discrete_interval<date>::rightopen(*week_iter, *week_iter + days(2));
+ weekends += discrete_interval<date>::right_open(*week_iter, *week_iter + days(2));
 
     weekends &= scope; // cut off the surplus
 
@@ -67,7 +67,7 @@
     date someday = from_string("2008-08-01");
     date thenday = someday + months(3);
 
- discrete_interval<date> scope = discrete_interval<date>::rightopen(someday, thenday);
+ discrete_interval<date> scope = discrete_interval<date>::right_open(someday, thenday);
 
     // ------------------------------------------------------------------------
     // (1) In a first step, the regular working times are computed for the

Modified: sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp (original)
+++ sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -53,7 +53,7 @@
     month_iterator month_iter(frame_months_1st);
 
     for(; month_iter <= last(scope); ++month_iter)
- month_grid += discrete_interval<date>::rightopen(*month_iter, *month_iter + months(1));
+ month_grid += discrete_interval<date>::right_open(*month_iter, *month_iter + months(1));
 
     month_grid &= scope; // cut off the surplus
 
@@ -71,7 +71,7 @@
     week_iterator week_iter(frame_weeks_1st);
 
     for(; week_iter <= last(scope); ++week_iter)
- week_grid.insert(discrete_interval<date>::rightopen(*week_iter, *week_iter + weeks(1)));
+ week_grid.insert(discrete_interval<date>::right_open(*week_iter, *week_iter + weeks(1)));
 
     week_grid &= scope; // cut off the surplus
 
@@ -86,7 +86,7 @@
     date someday = day_clock::local_day();
     date thenday = someday + months(2);
 
- discrete_interval<date> itv = discrete_interval<date>::rightopen(someday, thenday);
+ discrete_interval<date> itv = discrete_interval<date>::right_open(someday, thenday);
 
     // Compute a month grid
     date_grid month_and_week_grid = month_grid(itv);

Modified: sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp (original)
+++ sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -59,19 +59,19 @@
     OverlapCounterT overlap_counter;
     discrete_interval<int> inter_val;
 
- inter_val = discrete_interval<int>::rightopen(4,8);
+ inter_val = discrete_interval<int>::right_open(4,8);
     cout << "-- adding " << inter_val << " -----------------------------------------" << endl;
     overlap_counter += make_pair(inter_val, 1);
     print_overlaps(overlap_counter);
     cout << "-----------------------------------------------------------" << endl;
 
- inter_val = discrete_interval<int>::rightopen(6,9);
+ inter_val = discrete_interval<int>::right_open(6,9);
     cout << "-- adding " << inter_val << " -----------------------------------------" << endl;
     overlap_counter += make_pair(inter_val, 1);
     print_overlaps(overlap_counter);
     cout << "-----------------------------------------------------------" << endl;
 
- inter_val = discrete_interval<int>::rightopen(1,9);
+ inter_val = discrete_interval<int>::right_open(1,9);
     cout << "-- adding " << inter_val << " -----------------------------------------" << endl;
     overlap_counter += make_pair(inter_val, 1);
     print_overlaps(overlap_counter);

Modified: sandbox/itl/libs/itl/example/party_/party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/party_/party.cpp (original)
+++ sandbox/itl/libs/itl/example/party_/party.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -76,9 +76,9 @@
 
     interval_map<Time, GuestSetT> party;
 
- party += make_pair( discrete_interval<Time>::rightopen(Time(19,30), Time(23,00)), mary_harry);
- party += make_pair( discrete_interval<Time>::rightopen(Time(20,10), Time(monday,0,0)), diana_susan);
- party += make_pair( discrete_interval<Time>::rightopen(Time(22,15), Time(monday,0,30)), peter);
+ party += make_pair( discrete_interval<Time>::right_open(Time(19,30), Time(23,00)), mary_harry);
+ party += make_pair( discrete_interval<Time>::right_open(Time(20,10), Time(monday,0,0)), diana_susan);
+ party += make_pair( discrete_interval<Time>::right_open(Time(22,15), Time(monday,0,30)), peter);
 
     interval_map<Time, GuestSetT>::iterator it = party.begin();
     while(it != party.end())

Modified: sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -65,35 +65,35 @@
 
     height_sums +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 19:30"),
           time_from_string("2008-05-20 23:00")),
         counted_sum(165)); // Mary is 1,65 m tall.
 
     height_sums +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 19:30"),
           time_from_string("2008-05-20 23:00")),
         counted_sum(180)); // Harry is 1,80 m tall.
 
     height_sums +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 20:10"),
           time_from_string("2008-05-21 00:00")),
         counted_sum(170)); // Diana is 1,70 m tall.
 
     height_sums +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 20:10"),
           time_from_string("2008-05-21 00:00")),
         counted_sum(165)); // Susan is 1,65 m tall.
 
     height_sums +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 22:15"),
           time_from_string("2008-05-21 00:30")),
         counted_sum(200)); // Peters height is 2,00 m

Modified: sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -57,21 +57,21 @@
 
     tallest_guest +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 19:30"),
           time_from_string("2008-05-20 23:00")),
         180); // Mary & Harry: Harry is 1,80 m tall.
 
     tallest_guest +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 20:10"),
           time_from_string("2008-05-21 00:00")),
         170); // Diana & Susan: Diana is 1,70 m tall.
 
     tallest_guest +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 22:15"),
           time_from_string("2008-05-21 00:30")),
         200); // Peters height is 2,00 m
@@ -98,21 +98,21 @@
     // like e.g. min, max etc. in their 'inplace' or op= incarnation
     tallest_guest +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 19:30"),
           time_from_string("2008-05-20 23:00")),
         180); // Mary & Harry: Harry is 1,80 m tall.
 
     tallest_guest +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 20:10"),
           time_from_string("2008-05-21 00:00")),
         170); // Diana & Susan: Diana is 1,70 m tall.
 
     tallest_guest +=
       make_pair(
- discrete_interval<ptime>::rightopen(
+ discrete_interval<ptime>::right_open(
           time_from_string("2008-05-20 22:15"),
           time_from_string("2008-05-21 00:30")),
         200); // Peters height is 2,00 m

Modified: sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp (original)
+++ sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -35,9 +35,9 @@
 vector<pair<discrete_interval<int>, int> > make_segments()
 {
     vector<pair<discrete_interval<int>, int> > segment_vec;
- segment_vec.push_back(make_pair(discrete_interval<int>::rightopen(2,4), 1));
- segment_vec.push_back(make_pair(discrete_interval<int>::rightopen(4,5), 1));
- segment_vec.push_back(make_pair(discrete_interval<int>::rightopen(1,3), 1));
+ segment_vec.push_back(make_pair(discrete_interval<int>::right_open(2,4), 1));
+ segment_vec.push_back(make_pair(discrete_interval<int>::right_open(4,5), 1));
+ segment_vec.push_back(make_pair(discrete_interval<int>::right_open(1,3), 1));
     return segment_vec;
 }
 

Modified: sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -45,28 +45,28 @@
 
 //- sta.asy.{dis|con} ----------------------------------------------------------
 BOOST_AUTO_TEST_CASE
-(fastest_itl_rightopen_interval_ctor_4_ordered_types)
-{ interval_ctor_4_ordered_types<rightopen_interval<ordered_type_1> >(); }
+(fastest_itl_right_open_interval_ctor_4_ordered_types)
+{ interval_ctor_4_ordered_types<right_open_interval<ordered_type_1> >(); }
 
 BOOST_AUTO_TEST_CASE
-(fastest_itl_rightopen_interval_4_ordered_types)
-{ singelizable_interval_4_ordered_types<rightopen_interval<discrete_type_1> >(); }
+(fastest_itl_right_open_interval_4_ordered_types)
+{ singelizable_interval_4_ordered_types<right_open_interval<discrete_type_1> >(); }
 
 BOOST_AUTO_TEST_CASE
-(fastest_itl_rightopen_interval_4_bicremental_types)
-{ singelizable_interval_4_bicremental_types<rightopen_interval<discrete_type_2> >(); }
+(fastest_itl_right_open_interval_4_bicremental_types)
+{ singelizable_interval_4_bicremental_types<right_open_interval<discrete_type_2> >(); }
 
 BOOST_AUTO_TEST_CASE
-(fastest_itl_leftopen_interval_ctor_4_ordered_types)
-{ interval_ctor_4_ordered_types<leftopen_interval<ordered_type_2> >(); }
+(fastest_itl_left_open_interval_ctor_4_ordered_types)
+{ interval_ctor_4_ordered_types<left_open_interval<ordered_type_2> >(); }
 
 BOOST_AUTO_TEST_CASE
-(fastest_itl_leftopen_interval_4_ordered_types_singelizable)
-{ singelizable_interval_4_ordered_types<leftopen_interval<signed_discrete_type_1> >(); }
+(fastest_itl_left_open_interval_4_ordered_types_singelizable)
+{ singelizable_interval_4_ordered_types<left_open_interval<signed_discrete_type_1> >(); }
 
 BOOST_AUTO_TEST_CASE
-(fastest_itl_leftopen_interval_4_bicremental_types)
-{ singelizable_interval_4_bicremental_types<leftopen_interval<discrete_type_4> >(); }
+(fastest_itl_left_open_interval_4_bicremental_types)
+{ singelizable_interval_4_bicremental_types<left_open_interval<discrete_type_4> >(); }
 
 
 //- dyn.dis --------------------------------------------------------------------

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -51,7 +51,7 @@
 BOOST_AUTO_TEST_CASE(reverse_iter)
 {
     interval_map<int,int> map_a;
- map_a += make_pair(interval<int>::rightopen(0,3),1);
+ map_a += make_pair(interval<int>::right_open(0,3),1);
     cout << map_a << endl;
 
     for(interval_map<int,int>::element_iterator elem = elements_begin(map_a);

Modified: sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -24,8 +24,8 @@
 template <class T, ITL_COMPARE Compare>
 void distant_intervals_4_numeric_continuous_types()
 {
- typedef rightopen_interval<T,Compare> L__D; // L__D for [..)
- typedef leftopen_interval<T,Compare> C__I; // C__I for (..]
+ typedef right_open_interval<T,Compare> L__D; // L__D for [..)
+ typedef left_open_interval<T,Compare> C__I; // C__I for (..]
     typedef continuous_interval<T,Compare> IntervalT;
 
     BOOST_CHECK( is_interval<L__D>::value );

Modified: sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -32,8 +32,8 @@
 template <class T, ITL_COMPARE Compare>
 void distant_intervals_4_discrete_types()
 {
- typedef rightopen_interval<T,Compare> L__D; // L__D for [..)
- typedef leftopen_interval<T,Compare> C__I; // C__I for (..]
+ typedef right_open_interval<T,Compare> L__D; // L__D for [..)
+ typedef left_open_interval<T,Compare> C__I; // C__I for (..]
     typedef closed_interval<T,Compare> L__I; // L__I for [..]
     typedef open_interval<T,Compare> C__D; // C__D for (..)
     typedef discrete_interval<T,Compare> IntervalT;

Modified: sandbox/itl/libs/itl/test/test_icl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -50,7 +50,7 @@
     // Singleton ctor and singleness
     // LAW: !is_asymmetric_continuous(IntervalT) => size(singleton(x))==1
     // LAW: This law applies to all discrete and to dynamic continuous intervals
- // LAW: No singletons can be constructed for static continuous rightopen and leftopen intervals
+ // LAW: No singletons can be constructed for static continuous right_open and left_open intervals
     typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
     typedef typename itl::size_type_of<T>::type SizeT;
     T t_0 = itl::identity_element<T>::value();

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -122,9 +122,9 @@
     T v5 = make<T>(5);
 
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
     std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
@@ -152,9 +152,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
     std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
@@ -184,9 +184,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
     std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
@@ -474,9 +474,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
     std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
@@ -517,9 +517,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
     std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
@@ -565,12 +565,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
@@ -649,12 +649,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
@@ -735,12 +735,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
@@ -845,12 +845,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
@@ -940,12 +940,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
@@ -1045,14 +1045,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I1_8D = IntervalT::right_open(v1,v8);
+ IntervalT I2_7D = IntervalT::right_open(v2,v7);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I6_7D = IntervalT::right_open(v6,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
@@ -1115,7 +1115,7 @@
     split_AB &= mapping_pair<T,U>(v1,u1);
     split_AB += make_pair(IntervalT::open(v1,v7), u2);
     split_ab2.clear();
- split_ab2 += make_pair(IntervalT::rightopen(v1,v7), u2);
+ split_ab2 += make_pair(IntervalT::right_open(v1,v7), u2);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 }
@@ -1145,14 +1145,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I1_8D = IntervalT::right_open(v1,v8);
+ IntervalT I2_7D = IntervalT::right_open(v2,v7);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I6_7D = IntervalT::right_open(v6,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
     std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
@@ -1214,7 +1214,7 @@
     split_AB &= IntervalT(v1);
     split_AB += make_pair(IntervalT::open(v1,v7), u1);
     split_ab2.clear();
- split_ab2 += make_pair(IntervalT::rightopen(v1,v7), u1);
+ split_ab2 += make_pair(IntervalT::right_open(v1,v7), u1);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 
@@ -1255,14 +1255,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_2D = IntervalT::right_open(v1,v2);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I5_8D = IntervalT::right_open(v5,v8);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
     std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
@@ -1338,14 +1338,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_2D = IntervalT::right_open(v1,v2);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I5_8D = IntervalT::right_open(v5,v8);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
     std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
@@ -1412,9 +1412,9 @@
     T v4 = make<T>(4);
     T v6 = make<T>(6);
 
- IntervalT I0_2D = IntervalT::rightopen(v0,v2);
- IntervalT I2_3D = IntervalT::rightopen(v2,v3);
- IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I0_2D = IntervalT::right_open(v0,v2);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I3_4D = IntervalT::right_open(v3,v4);
     IntervalT I4_4I = IntervalT::closed(v4,v4);
     IntervalT C4_6D = IntervalT::open(v4,v6);
     IntervalT I6_6I = IntervalT::closed(v6,v6);
@@ -1469,9 +1469,9 @@
     T v4 = make<T>(4);
     T v6 = make<T>(6);
 
- IntervalT I0_3D = IntervalT::rightopen(v0,v3);
- IntervalT I2_3D = IntervalT::rightopen(v2,v3);
- IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I3_4D = IntervalT::right_open(v3,v4);
     IntervalT I4_4I = IntervalT::closed(v4,v4);
     IntervalT C4_6D = IntervalT::open(v4,v6);
     IntervalT I6_6I = IntervalT::closed(v6,v6);

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -581,16 +581,16 @@
 
     U u1 = make<U>(1);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I1_4D = IntervalT::right_open(v1,v4);
+ IntervalT I1_8D = IntervalT::right_open(v1,v8);
+ IntervalT I2_7D = IntervalT::right_open(v2,v7);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I5_8D = IntervalT::right_open(v5,v8);
+ IntervalT I6_7D = IntervalT::right_open(v6,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
     typename IntervalMapT::value_type I6_9D_1(I6_9D, u1);
@@ -688,22 +688,22 @@
 
     U u1 = make<U>(1);
 
- 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);
+ IntervalT I0_1D = IntervalT::right_open(v0,v1);
+ IntervalT I0_2D = IntervalT::right_open(v0,v2);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I1_4D = IntervalT::right_open(v1,v4);
+ IntervalT I1_8D = IntervalT::right_open(v1,v8);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I2_7D = IntervalT::right_open(v2,v7);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I5_8D = IntervalT::right_open(v5,v8);
+ IntervalT I6_7D = IntervalT::right_open(v6,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
+ IntervalT I7_9D = IntervalT::right_open(v7,v9);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
 
     typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
     typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
@@ -805,12 +805,12 @@
 
     U u1 = make<U>(1);
 
- 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);
+ IntervalT I0_1D = IntervalT::right_open(v0,v1);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
 
     typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
     typename IntervalMapT::value_type I1_3D_1(I1_3D, u1);

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -135,9 +135,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     split_interval_set<T> split_set;
     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -168,9 +168,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     split_interval_set<T> split_set;
     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -206,9 +206,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     interval_set<T> join_set;
     join_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -269,9 +269,9 @@
     T v4 = make<T>(4);
     T v5 = make<T>(5);
 
- IntervalT I1_3D = IntervalT::rightopen(v1,v3);
- IntervalT I2_4D = IntervalT::rightopen(v2,v4);
- IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I4_5D = IntervalT::right_open(v4,v5);
 
     split_interval_set<T> split_set;
     split_set.add(I1_3D).add(I2_4D);
@@ -323,12 +323,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     split_interval_set<T> split_set;
@@ -434,12 +434,12 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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 I0_4D = IntervalT::right_open(v0,v4);
+ IntervalT I2_6D = IntervalT::right_open(v2,v6);
+ IntervalT I3_6D = IntervalT::right_open(v3,v6);
+ IntervalT I5_7D = IntervalT::right_open(v5,v7);
+ IntervalT I7_8D = IntervalT::right_open(v7,v8);
+ IntervalT I8_9D = IntervalT::right_open(v8,v9);
     IntervalT I8_9I = IntervalT::closed(v8,v9);
 
     split_interval_set<T> split_set;
@@ -543,14 +543,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I1_8D = IntervalT::right_open(v1,v8);
+ IntervalT I2_7D = IntervalT::right_open(v2,v7);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I6_7D = IntervalT::right_open(v6,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     //--------------------------------------------------------------------------
     // split_interval_set
@@ -593,7 +593,7 @@
     split_AB = split_A;
     (split_AB &= v1) += IntervalT::open(v1,v7);
     split_ab2.clear();
- split_ab2 += IntervalT::rightopen(v1,v7);
+ split_ab2 += IntervalT::right_open(v1,v7);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 }
@@ -615,14 +615,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_2D = IntervalT::right_open(v1,v2);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I2_4D = IntervalT::right_open(v2,v4);
+ IntervalT I5_8D = IntervalT::right_open(v5,v8);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     //--------------------------------------------------------------------------
     // split_interval_set
@@ -747,9 +747,9 @@
     T v4 = make<T>(4);
     T v6 = make<T>(6);
    
- IntervalT I0_2D = IntervalT::rightopen(v0,v2);
- IntervalT I2_3D = IntervalT::rightopen(v2,v3);
- IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I0_2D = IntervalT::right_open(v0,v2);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I3_4D = IntervalT::right_open(v3,v4);
     IntervalT I4_4I = IntervalT::closed(v4,v4);
     IntervalT C4_6D = IntervalT::open(v4,v6);
     IntervalT I6_6I = IntervalT::closed(v6,v6);

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -517,14 +517,14 @@
     T v8 = make<T>(8);
     T v9 = make<T>(9);
 
- 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);
+ IntervalT I0_3D = IntervalT::right_open(v0,v3);
+ IntervalT I1_3D = IntervalT::right_open(v1,v3);
+ IntervalT I1_8D = IntervalT::right_open(v1,v8);
+ IntervalT I2_7D = IntervalT::right_open(v2,v7);
+ IntervalT I2_3D = IntervalT::right_open(v2,v3);
+ IntervalT I6_7D = IntervalT::right_open(v6,v7);
+ IntervalT I6_8D = IntervalT::right_open(v6,v8);
+ IntervalT I6_9D = IntervalT::right_open(v6,v9);
 
     //--------------------------------------------------------------------------
     // IntervalSet
@@ -567,7 +567,7 @@
     split_AB = split_A;
     (split_AB &= v1) += IntervalT::open(v1,v7);
     split_ab2.clear();
- split_ab2 += IntervalT::rightopen(v1,v7);
+ split_ab2 += IntervalT::right_open(v1,v7);
 
     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 }

Modified: sandbox/itl/libs/itl/test/test_itl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -11,7 +11,7 @@
 template <class T, class IntervalT>
 void interval_ctor_4_ordered_types()
 {
- T lower_bound = given<mpl::or_<is_static_rightopen<IntervalT>, is_static_open<IntervalT> >, T>
+ T lower_bound = given<mpl::or_<is_static_right_open<IntervalT>, is_static_open<IntervalT> >, T>
                         ::then(identity_element<T>::value(), unit_element<T>::value());
 
     typedef typename domain_type_of<IntervalT>::type Dom1T;
@@ -73,8 +73,8 @@
     T v2 = make<T>(2);
     BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4) );
     BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4, closed_bounded) );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4), interval<T>(v2, v4, right_open) );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4), interval<T>(v2, v4, left_open) );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4), interval<T>(v2, v4, right_open) );
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4), interval<T>(v2, v4, left_open) );
     BOOST_CHECK_EQUAL( interval<T>::open(v2, v4), interval<T>(v2, v4, open_bounded) );
 
     BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).lower(), v2 );
@@ -84,19 +84,19 @@
     BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_left(closed_bounded), true );
     BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_right(closed_bounded), true );
 
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).lower(), v2 );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).upper(), v4 );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).boundtype(), right_open );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is(right_open), true );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_left(closed_bounded), true );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_right(open_bounded), true );
-
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).lower(), v2 );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).upper(), v4 );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).boundtype(), left_open );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is(left_open), true );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_left(open_bounded), true );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_right(closed_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).lower(), v2 );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).upper(), v4 );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).boundtype(), right_open );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).is(right_open), true );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).is_left(closed_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).is_right(open_bounded), true );
+
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).lower(), v2 );
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).upper(), v4 );
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).boundtype(), left_open );
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).is(left_open), true );
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).is_left(open_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).is_right(closed_bounded), true );
 
     BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).lower(), v2 );
     BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).upper(), v4 );
@@ -137,8 +137,8 @@
     //C: left open bound
     //D: right open bound
     interval<T> I3_7I = interval<T>::closed(v3,v7);
- interval<T> I3__8D = interval<T>::rightopen(v3,v8);
- interval<T> C2__7I = interval<T>::leftopen(v2,v7);
+ interval<T> I3__8D = interval<T>::right_open(v3,v8);
+ interval<T> C2__7I = interval<T>::left_open(v2,v7);
     interval<T> C2___8D = interval<T>::open(v2,v8);
 
     BOOST_CHECK_EQUAL( I3_7I , I3_7I );
@@ -166,11 +166,11 @@
     T v7 = make<T>(7);
     T v8 = make<T>(8);
     BOOST_CHECK_EQUAL(interval<T>() < interval<T>(v7,v3), false);
- BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::rightopen(v7,v7), false);
- BOOST_CHECK_EQUAL(interval<T>::leftopen(v3,v3) < interval<T>::closed(v7,v3), false);
+ BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::right_open(v7,v7), false);
+ BOOST_CHECK_EQUAL(interval<T>::left_open(v3,v3) < interval<T>::closed(v7,v3), false);
 
     BOOST_CHECK_EQUAL(interval<T>() < interval<T>(v3,v3), true);
- BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::rightopen(v7,v8), true);
+ BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::right_open(v7,v8), true);
 
     //I: (I)nside = closed bound
     //C: left open bound
@@ -178,8 +178,8 @@
     interval<T> I3_7I = interval<T>::closed(v3,v7);
     interval<T> I4_7I = interval<T>::closed(v4,v7);
 
- interval<T> I3__8D = interval<T>::rightopen(v3,v8);
- interval<T> C2__7I = interval<T>::leftopen(v2,v7);
+ interval<T> I3__8D = interval<T>::right_open(v3,v8);
+ interval<T> C2__7I = interval<T>::left_open(v2,v7);
     interval<T> C2___8D = interval<T>::open(v2,v8);
 
     BOOST_CHECK_EQUAL( I3_7I < I3_7I , false);
@@ -211,8 +211,8 @@
     //I: (I)nside = closed bound
     //O: (O)utside = open bound
     interval<T> I3_7I = interval<T>::closed(v3,v7);
- interval<T> I3_7D = interval<T>::rightopen(v3,v7);
- interval<T> C3_7I = interval<T>::leftopen(v3,v7);
+ interval<T> I3_7D = interval<T>::right_open(v3,v7);
+ interval<T> C3_7I = interval<T>::left_open(v3,v7);
     interval<T> C3_7D = interval<T>::open(v3,v7);
 
     BOOST_CHECK_EQUAL( I3_7I , I3_7I );
@@ -243,12 +243,12 @@
     T v7 = make<T>(7);
     T v9 = make<T>(9);
 
- interval<T> I3_7D = interval<T>::rightopen(v3,v7);
+ interval<T> I3_7D = interval<T>::right_open(v3,v7);
     interval<T> I7_9I = interval<T>::closed(v7,v9);
     BOOST_CHECK_EQUAL( I3_7D.touches(I7_9I), true );
 
     interval<T> I3_7I = interval<T>::closed(v3,v7);
- interval<T> C7_9I = interval<T>::leftopen(v7,v9);
+ interval<T> C7_9I = interval<T>::left_open(v7,v9);
     BOOST_CHECK_EQUAL( I3_7I.touches(C7_9I), true );
 
     BOOST_CHECK_EQUAL( I3_7D.touches(C7_9I), false );
@@ -267,8 +267,8 @@
     interval<T> I7_9I = interval<T>::closed(v7,v9);
     BOOST_CHECK_EQUAL( I3_6I.touches(I7_9I), true );
 
- interval<T> I3_7D = interval<T>::rightopen(v3,v7);
- interval<T> C6_9I = interval<T>::leftopen(v6,v9);
+ interval<T> I3_7D = interval<T>::right_open(v3,v7);
+ interval<T> C6_9I = interval<T>::left_open(v6,v9);
     BOOST_CHECK_EQUAL( I3_7D.touches(C6_9I), true );
 }
 
@@ -285,9 +285,9 @@
     T v9 = make<T>(9);
 
     interval<T> section;
- interval<T> I3_7D = interval<T>::rightopen(v3,v7);
+ interval<T> I3_7D = interval<T>::right_open(v3,v7);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
+ interval<T> I0_3D = interval<T>::right_open(v0,v3);
     section = I3_7D; section &= I0_3D;
     BOOST_CHECK_EQUAL( I0_3D.is_disjoint(I3_7D), true );
     BOOST_CHECK_EQUAL( !I0_3D.intersects(I3_7D), true );
@@ -296,11 +296,11 @@
     BOOST_CHECK_EQUAL( section.empty(), true );
     BOOST_CHECK_EQUAL( section, interval<T>() );
 
- interval<T> I0_5D = interval<T>::rightopen(v0,v5);
+ interval<T> I0_5D = interval<T>::right_open(v0,v5);
     section = I3_7D; section &= I0_5D;
- BOOST_CHECK_EQUAL( section, interval<T>::rightopen(v3, v5) );
+ BOOST_CHECK_EQUAL( section, interval<T>::right_open(v3, v5) );
 
- interval<T> I0_9D = interval<T>::rightopen(v0,v9);
+ interval<T> I0_9D = interval<T>::right_open(v0,v9);
     section = I3_7D; section &= I0_9D;
     BOOST_CHECK_EQUAL( section, I3_7D );
 
@@ -312,7 +312,7 @@
     section = I3_7D; section &= C4_6D;
     BOOST_CHECK_EQUAL( section, C4_6D );
 
- interval<T> C4_9I = interval<T>::leftopen(v4,v9);
+ interval<T> C4_9I = interval<T>::left_open(v4,v9);
     section = I3_7D; section &= C4_9I;
     BOOST_CHECK_EQUAL( section, interval<T>::open(v4,v7) );
 
@@ -338,19 +338,19 @@
     T v9 = make<T>(9);
 
     interval<T> section;
- interval<T> I3_7D = interval<T>::rightopen(v3,v7);
+ interval<T> I3_7D = interval<T>::right_open(v3,v7);
 
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
+ interval<T> I0_3D = interval<T>::right_open(v0,v3);
     section = I3_7D & I0_3D;
     BOOST_CHECK_EQUAL( I0_3D.is_disjoint(I3_7D), true );
     BOOST_CHECK_EQUAL( section.empty(), true );
     BOOST_CHECK_EQUAL( section, interval<T>() );
 
- interval<T> I0_5D = interval<T>::rightopen(v0,v5);
+ interval<T> I0_5D = interval<T>::right_open(v0,v5);
     section = I3_7D & I0_5D;
- BOOST_CHECK_EQUAL( section, interval<T>::rightopen(v3, v5) );
+ BOOST_CHECK_EQUAL( section, interval<T>::right_open(v3, v5) );
 
- interval<T> I0_9D = interval<T>::rightopen(v0,v9);
+ interval<T> I0_9D = interval<T>::right_open(v0,v9);
     section = I3_7D & I0_9D;
     BOOST_CHECK_EQUAL( section, I3_7D );
 
@@ -362,7 +362,7 @@
     section = I3_7D & C4_6D;
     BOOST_CHECK_EQUAL( section, C4_6D );
 
- interval<T> C4_9I = interval<T>::leftopen(v4,v9);
+ interval<T> C4_9I = interval<T>::left_open(v4,v9);
     section = I3_7D & C4_9I;
     BOOST_CHECK_EQUAL( section, interval<T>::open(v4,v7) );
 
@@ -384,11 +384,11 @@
     T v7 = make<T>(7);
 
     interval<T> diff_1, diff_2;
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I4_7D = interval<T>::rightopen(v4,v7);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
+ interval<T> I0_3D = interval<T>::right_open(v0,v3);
+ interval<T> I2_6D = interval<T>::right_open(v2,v6);
+ interval<T> I4_7D = interval<T>::right_open(v4,v7);
+ interval<T> I6_7D = interval<T>::right_open(v6,v7);
+ interval<T> I2_4D = interval<T>::right_open(v2,v4);
 
     diff_1 = right_subtract(I2_6D, I4_7D);
     BOOST_CHECK_EQUAL( diff_1, I2_4D );

Modified: sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -39,28 +39,28 @@
 
 //- sta.asy.{dis|con} ----------------------------------------------------------
 BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_rightopen_interval_ctor_4_ordered_types, T, ordered_types)
-{ interval_ctor_4_ordered_types<rightopen_interval<T> >(); }
+(test_itl_right_open_interval_ctor_4_ordered_types, T, ordered_types)
+{ interval_ctor_4_ordered_types<right_open_interval<T> >(); }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_rightopen_interval_4_ordered_types, T, discrete_types)
-{ singelizable_interval_4_ordered_types<rightopen_interval<T> >(); }
+(test_itl_right_open_interval_4_ordered_types, T, discrete_types)
+{ singelizable_interval_4_ordered_types<right_open_interval<T> >(); }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_rightopen_interval_4_bicremental_types, T, discrete_types)
-{ singelizable_interval_4_bicremental_types<rightopen_interval<T> >(); }
+(test_itl_right_open_interval_4_bicremental_types, T, discrete_types)
+{ singelizable_interval_4_bicremental_types<right_open_interval<T> >(); }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_leftopen_interval_ctor_4_ordered_types, T, ordered_types)
-{ interval_ctor_4_ordered_types<leftopen_interval<T> >(); }
+(test_itl_left_open_interval_ctor_4_ordered_types, T, ordered_types)
+{ interval_ctor_4_ordered_types<left_open_interval<T> >(); }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_leftopen_interval_4_ordered_types_singelizable, T, signed_discrete_types)
-{ singelizable_interval_4_ordered_types<leftopen_interval<T> >(); }
+(test_itl_left_open_interval_4_ordered_types_singelizable, T, signed_discrete_types)
+{ singelizable_interval_4_ordered_types<left_open_interval<T> >(); }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_leftopen_interval_4_bicremental_types, T, discrete_types)
-{ singelizable_interval_4_bicremental_types<leftopen_interval<T> >(); }
+(test_itl_left_open_interval_4_bicremental_types, T, discrete_types)
+{ singelizable_interval_4_bicremental_types<left_open_interval<T> >(); }
 
 //------------------------------------------------------------------------------
 

Modified: sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -72,8 +72,8 @@
     //T v2 = make<T>(2);
     //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4) );
     //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4, closed_bounded) );
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4), interval<T>(v2, v4, right_open) );
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4), interval<T>(v2, v4, left_open) );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4), interval<T>(v2, v4, right_open) );
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4), interval<T>(v2, v4, left_open) );
     //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4), interval<T>(v2, v4, open_bounded) );
 
     //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).lower(), v2 );
@@ -83,19 +83,19 @@
     //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_left(closed_bounded), true );
     //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_right(closed_bounded), true );
 
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).lower(), v2 );
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).upper(), v4 );
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).boundtype(), right_open );
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).bounds() == interval_bounds::right_open(), true );
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_left(closed_bounded), true );
- //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_right(open_bounded), true );
-
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).lower(), v2 );
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).upper(), v4 );
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).boundtype(), left_open );
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).bounds() == interval_bounds::left_open(), true );
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_left(open_bounded), true );
- //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_right(closed_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).lower(), v2 );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).upper(), v4 );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).boundtype(), right_open );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).bounds() == interval_bounds::right_open(), true );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).is_left(closed_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::right_open(v2, v4).is_right(open_bounded), true );
+
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).lower(), v2 );
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).upper(), v4 );
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).boundtype(), left_open );
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).bounds() == interval_bounds::left_open(), true );
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).is_left(open_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::left_open(v2, v4).is_right(closed_bounded), true );
 
     //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).lower(), v2 );
     //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).upper(), v4 );
@@ -117,8 +117,8 @@
 // //I: (I)nside = closed bound
 // //O: (O)utside = open bound
 // interval<T> I3_7I = interval<T>::closed(v3,v7);
-// interval<T> I3_7D = interval<T>::rightopen(v3,v7);
-// interval<T> C3_7I = interval<T>::leftopen(v3,v7);
+// interval<T> I3_7D = interval<T>::right_open(v3,v7);
+// interval<T> C3_7I = interval<T>::left_open(v3,v7);
 // interval<T> C3_7D = interval<T>::open(v3,v7);
 //
 // BOOST_CHECK_EQUAL( I3_7I , I3_7I );

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -137,9 +137,9 @@
 //I_I : [a,b]
 #define I_I(low,up) IntervalT::closed (make<T>(low), make<T>(up))
 //I_D : [a,b)
-#define I_D(low,up) IntervalT::rightopen(make<T>(low), make<T>(up))
+#define I_D(low,up) IntervalT::right_open(make<T>(low), make<T>(up))
 //C_I : (a,b]
-#define C_I(low,up) IntervalT::leftopen (make<T>(low), make<T>(up))
+#define C_I(low,up) IntervalT::left_open (make<T>(low), make<T>(up))
 //C_D : (a,b)
 #define C_D(low,up) IntervalT::open (make<T>(low), make<T>(up))
 
@@ -151,8 +151,8 @@
 // Very short value denotation for interval value pairs
 // Assumption typename IntervalMapT existes in scope
 #define IIv(low,up,val) map_val<IntervalMapT>::val_pair(low,up,val, interval_bounds::_closed)
-#define IDv(low,up,val) map_val<IntervalMapT>::val_pair(low,up,val, interval_bounds::_rightopen)
-#define CIv(low,up,val) map_val<IntervalMapT>::val_pair(low,up,val, interval_bounds::_leftopen)
+#define IDv(low,up,val) map_val<IntervalMapT>::val_pair(low,up,val, interval_bounds::_right_open)
+#define CIv(low,up,val) map_val<IntervalMapT>::val_pair(low,up,val, interval_bounds::_left_open)
 #define CDv(low,up,val) map_val<IntervalMapT>::val_pair(low,up,val, interval_bounds::_open)
 #define K_v(key,val) map_val<IntervalMapT>::map_pair(key,val)
 #define sK_v(key,val) map_val<IntervalMapT>::std_pair(key,val)

Modified: sandbox/itl/libs/itl_xt/example/history_/history.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/example/history_/history.cpp (original)
+++ sandbox/itl/libs/itl_xt/example/history_/history.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -13,7 +13,7 @@
 
 // Prior to other includes for interval containers we define ...
 #define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
-// ... so all interval containers will use rightopen_intervals that
+// ... so all interval containers will use right_open_intervals that
 // has static interval borders.
 
 #include <boost/itl/type_traits/to_string.hpp>
@@ -127,7 +127,7 @@
     // The domain type of intervals used by HospitalEpisodes is (toy)Time
     typedef Time ItvDomTD;
     // Type of the intervals used by HospitalEpisodes
- typedef rightopen_interval<Time> IntervalTD;
+ typedef right_open_interval<Time> IntervalTD;
 
 public:
     // Construct an episode from interval and value
@@ -164,7 +164,7 @@
 {
 public:
     DiagnosisEpisode(Time begin, Time end, const std::string& val)
- : HospitalEpisodes(rightopen_interval<Time>(begin,end),val){}
+ : HospitalEpisodes(right_open_interval<Time>(begin,end),val){}
 
     HospitalTypeDomain::DomainET type()const { return HospitalTypeDomain::diagnosis; }
 };
@@ -174,7 +174,7 @@
 {
 public:
     WardEpisode(Time begin, Time end, const std::string& val)
- : HospitalEpisodes(rightopen_interval<Time>(begin,end),val){}
+ : HospitalEpisodes(right_open_interval<Time>(begin,end),val){}
 
     HospitalTypeDomain::DomainET type()const { return HospitalTypeDomain::ward; }
 };
@@ -219,7 +219,7 @@
     HospitalProductHistory::iterator it = history.begin();
     while(it != history.end())
     {
- rightopen_interval<Time> when = (*it).first;
+ right_open_interval<Time> when = (*it).first;
         HospitalEventTD what = (*it).second;
 
         cout << when << ": " << what.as_string() << endl;

Modified: sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp (original)
+++ sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -184,8 +184,8 @@
     //noplum.insert(mapping_pair<int,NoPlus>(42,NoPlus(14)));
     //noplum.erase(mapping_pair<int,NoPlus>(42,NoPlus(14)));
     
- noplum.insert(make_pair(interval<int>::rightopen(2,6),NoPlus(1)));
- noplum.insert(make_pair(interval<int>::rightopen(4,8),NoPlus(2)));
+ noplum.insert(make_pair(interval<int>::right_open(2,6),NoPlus(1)));
+ noplum.insert(make_pair(interval<int>::right_open(4,8),NoPlus(2)));
 
     cout << noplum << endl;
 }
@@ -195,8 +195,8 @@
 {
     typedef interval_map<int,std::string> ConcaMapT;
     ConcaMapT cat_map;
- cat_map += make_pair(interval<int>::rightopen(1,5),std::string("Hello"));
- cat_map += make_pair(interval<int>::rightopen(3,7),std::string(" World"));
+ cat_map += make_pair(interval<int>::right_open(1,5),std::string("Hello"));
+ cat_map += make_pair(interval<int>::right_open(3,7),std::string(" World"));
     
     cout << "cat_map: " << cat_map << endl;
 }
@@ -205,9 +205,9 @@
 {
     typedef interval_map<int,int> QuantifierT;
     QuantifierT sec_map;
- sec_map += make_pair(interval<int>::rightopen(1,5), 1);
- sec_map &= make_pair(interval<int>::rightopen(3,7), 1);
- //sec_map &= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
+ sec_map += make_pair(interval<int>::right_open(1,5), 1);
+ sec_map &= make_pair(interval<int>::right_open(3,7), 1);
+ //sec_map &= QuantifierT(make_pair(interval<int>::right_open(3,7), 1));
     
     cout << "sec_map: " << sec_map << endl;
 }
@@ -216,10 +216,10 @@
 {
     typedef interval_map<int,cnat> QuantifierT;
     QuantifierT sec_map;
- sec_map += QuantifierT::value_type(interval<int>::rightopen(1,5), 1);
- sec_map -= make_pair(interval<int>::rightopen(3,7), static_cast<cnat>(2));
- sec_map += make_pair(interval<int>::rightopen(3,7), static_cast<cnat>(3));
- //sec_map *= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
+ sec_map += QuantifierT::value_type(interval<int>::right_open(1,5), 1);
+ sec_map -= make_pair(interval<int>::right_open(3,7), static_cast<cnat>(2));
+ sec_map += make_pair(interval<int>::right_open(3,7), static_cast<cnat>(3));
+ //sec_map *= QuantifierT(make_pair(interval<int>::right_open(3,7), 1));
     
     QuantifierT sec_map2;
 
@@ -234,9 +234,9 @@
 {
     typedef interval_map<int,int,partial_enricher> MapT;
     MapT m;
- m += MapT::value_type(interval<int>::rightopen(1,3), 1);
+ m += MapT::value_type(interval<int>::right_open(1,3), 1);
     cout << m << endl;
- m -= MapT::value_type(interval<int>::rightopen(1,3), 1);
+ m -= MapT::value_type(interval<int>::right_open(1,3), 1);
     cout << m << endl;
 }
 

Modified: sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -102,17 +102,17 @@
     typedef itl::list<PolygonT> PolygonSetT;
 
     point_gentor<int>* pointgen = new point_gentor<int>;
- pointgen->setRange(interval<int>::rightopen(-99, 100));
+ pointgen->setRange(interval<int>::right_open(-99, 100));
 
     PolygonT some_poly;
     polygon_gentor<PolygonT>* polygen = new polygon_gentor<PolygonT>;
     polygen->setDomainGentor(pointgen);
- polygen->setRangeOfSampleSize(interval<int>::rightopen(1, 5));
+ polygen->setRangeOfSampleSize(interval<int>::right_open(1, 5));
 
     PolygonSetT some_polyset;
     polygon_set_gentor<PolygonSetT> polysetgen;
     polysetgen.setDomainGentor(polygen);
- polysetgen.setRangeOfSampleSize(interval<int>::rightopen(1, 3));
+ polysetgen.setRangeOfSampleSize(interval<int>::right_open(1, 3));
 
     for(int idx=0; idx<10; idx++)
     {

Modified: sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp 2010-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -37,7 +37,7 @@
     }
 
     void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
+ { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
     void setRangeOfSampleSize(const interval<int>& szRange)
     { BOOST_ASSERT(szRange.is(right_open)); m_sampleSizeRange = szRange; }
 
@@ -137,7 +137,7 @@
     }
 
     void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
+ { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
     void setRangeOfSampleSize(const interval<int>& szRange)
     { BOOST_ASSERT(szRange.is(right_open)); m_sampleSizeRange = szRange; }
 

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-10-08 12:18:56 EDT (Fri, 08 Oct 2010)
@@ -76,7 +76,7 @@
 
     //typedef FunctionEquality
     //<
- // itl::list<std::pair<rightopen_interval<double,std::less>,int> >, //SourceT,
+ // itl::list<std::pair<right_open_interval<double,std::less>,int> >, //SourceT,
     // split_interval_map<double,int,partial_absorber>, //TargetT,
     // base_insertion,
     // hint_insertion

Date view Thread view Subject view Author view

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