[Boost-commit] svn:boost r75815 - in trunk: boost/icl boost/icl/concept boost/icl/type_traits libs/icl/test libs/icl/test/test_casual_

Subject: [Boost-commit] svn:boost r75815 - in trunk: boost/icl boost/icl/concept boost/icl/type_traits libs/icl/test libs/icl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2011-12-05 17:59:51

Author: jofaber
Date: 2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
New Revision: 75815
URL: http://svn.boost.org/trac/boost/changeset/75815

Log:
Bugfix ticket 6210. In addition: Some changes for introducing move semantics.
Text files modified: 
   trunk/boost/icl/concept/interval.hpp               |    40 +++++++++++++++++++-------------------  
   trunk/boost/icl/impl_config.hpp                    |    13 ++++-------                             
   trunk/boost/icl/interval_base_map.hpp              |    35 +++++++++++++++++++++++++++++++++       
   trunk/boost/icl/interval_base_set.hpp              |     1                                         
   trunk/boost/icl/interval_map.hpp                   |    12 ++++++++++                              
   trunk/boost/icl/map.hpp                            |    41 ++++++++++++++++++++++++++++++++++++++- 
   trunk/boost/icl/split_interval_map.hpp             |    22 +++++++++++++++++++-                    
   trunk/boost/icl/type_traits/is_numeric.hpp         |     1                                         
   trunk/libs/icl/test/fastest_interval_map_cases.hpp |     4 +++                                     
   trunk/libs/icl/test/test_casual_/test_casual.cpp   |    20 +++++++++---------                      
   trunk/libs/icl/test/test_icl_map.hpp               |    15 ++++++++++++++                          
   trunk/libs/icl/test/test_interval_map_shared.hpp   |    29 ++++++++++++++++++++++++++++            
   12 files changed, 189 insertions(+), 44 deletions(-)

Modified: trunk/boost/icl/concept/interval.hpp
==============================================================================
--- trunk/boost/icl/concept/interval.hpp	(original)
+++ trunk/boost/icl/concept/interval.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -609,8 +609,8 @@
     exclusive_less(const Type& left, const Type& right)
     { 
         BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
-        return     domain_less <Type>(left.upper(), right.lower())
-            || (   domain_equal<Type>(left.upper(), right.lower())
+        return     domain_less <Type>(upper(left), lower(right))
+            || (   domain_equal<Type>(upper(left), lower(right))
                 && inner_bounds(left,right) != interval_bounds::open() );
     }
 
@@ -663,12 +663,12 @@
 {
     return
         (is_left_closed(super.bounds())  
-            ? domain_less_equal<Type>(super.lower(), element) 
-            :       domain_less<Type>(super.lower(), element))
+            ? domain_less_equal<Type>(lower(super), element) 
+            :       domain_less<Type>(lower(super), element))
     &&
         (is_right_closed(super.bounds()) 
-            ? domain_less_equal<Type>(element, super.upper()) 
-            :       domain_less<Type>(element, super.upper()));
+            ? domain_less_equal<Type>(element, upper(super)) 
+            :       domain_less<Type>(element, upper(super)));
 }
 
 //- within ---------------------------------------------------------------------
@@ -716,8 +716,8 @@
 exclusive_less(const Type& left, const Type& right)
 { 
     return     icl::is_empty(left) || icl::is_empty(right)
-        ||     domain_less<Type>(left.upper(), right.lower())
-        || (   domain_equal<Type>(left.upper(), right.lower())
+        ||     domain_less<Type>(upper(left), lower(right))
+        || (   domain_equal<Type>(upper(left), lower(right))
             && inner_bounds(left,right) != interval_bounds::open() );
 }
 
@@ -727,7 +727,7 @@
 typename boost::enable_if<has_static_bounds<Type>, bool>::type
 lower_less(const Type& left, const Type& right)
 {
-    return domain_less<Type>(left.lower(), right.lower());
+    return domain_less<Type>(lower(left), lower(right));
 }
     
 template<class Type>
@@ -742,9 +742,9 @@
 lower_less(const Type& left, const Type& right)
 {
     if(left_bounds(left,right) == interval_bounds::right_open())  //'[(' == 10
-        return domain_less_equal<Type>(left.lower(), right.lower());
+        return domain_less_equal<Type>(lower(left), lower(right));
     else 
-        return domain_less<Type>(left.lower(), right.lower());
+        return domain_less<Type>(lower(left), lower(right));
 }
     
 
@@ -753,7 +753,7 @@
 typename boost::enable_if<has_static_bounds<Type>, bool>::type
 upper_less(const Type& left, const Type& right)
 {
-    return domain_less<Type>(left.upper(), right.upper());
+    return domain_less<Type>(upper(left), upper(right));
 }
 
 template<class Type>
@@ -768,9 +768,9 @@
 upper_less(const Type& left, const Type& right)
 {
     if(right_bounds(left,right) == interval_bounds::left_open())
-        return domain_less_equal<Type>(left.upper(), right.upper());
+        return domain_less_equal<Type>(upper(left), upper(right));
     else
-        return domain_less<Type>(left.upper(), right.upper());
+        return domain_less<Type>(upper(left), upper(right));
 }
     
 //------------------------------------------------------------------------------
@@ -815,7 +815,7 @@
 typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
 lower_equal(const Type& left, const Type& right)
 {
-    return domain_equal<Type>(left.lower(), right.lower());
+    return domain_equal<Type>(lower(left), lower(right));
 }
 
 template<class Type>
@@ -837,7 +837,7 @@
 lower_equal(const Type& left, const Type& right)
 {
     return (left.bounds().left()==right.bounds().left())
-        && domain_equal<Type>(left.lower(), right.lower());
+        && domain_equal<Type>(lower(left), lower(right));
 }
 
 
@@ -846,7 +846,7 @@
 typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
 upper_equal(const Type& left, const Type& right)
 {
-    return domain_equal<Type>(left.upper(), right.upper());
+    return domain_equal<Type>(upper(left), upper(right));
 }
 
 template<class Type>
@@ -868,7 +868,7 @@
 upper_equal(const Type& left, const Type& right)
 {
     return (left.bounds().right()==right.bounds().right())
-        && domain_equal<Type>(left.upper(), right.upper());
+        && domain_equal<Type>(upper(left), upper(right));
 }
 
 //------------------------------------------------------------------------------
@@ -951,7 +951,7 @@
 touches(const Type& left, const Type& right)
 {
     return is_complementary(inner_bounds(left,right))
-        && domain_equal<Type>(left.upper(), right.lower());
+        && domain_equal<Type>(upper(left), lower(right));
 }
 
 
@@ -1404,7 +1404,7 @@
     if(icl::is_empty(x1) || icl::is_empty(x2))
         return icl::identity_element<DiffT>::value();
     else if(domain_less<Type>(upper(x1), lower(x2)))
-        return x2.lower() - x1.upper();
+        return lower(x2) - upper(x1);
     else if(domain_less<Type>(upper(x2), lower(x1)))
         return lower(x1) - upper(x2);
     else

Modified: trunk/boost/icl/impl_config.hpp
==============================================================================
--- trunk/boost/icl/impl_config.hpp	(original)
+++ trunk/boost/icl/impl_config.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -25,19 +25,16 @@
 ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION: Choose set and map implementations 
     from boost::interprocess.
 
-ICL_USE_BOOST_MOVE_IMPLEMENTATION: Move aware containers from boost::container
-    (NEW) are used. Currently (January 2010) this is only experimental. 
-    boost::move from the boost::sandbox has to be used. This is depreciated for 
-    production code, as long as move aware containers are not officially 
-    accepted into boost. 
+ICL_USE_BOOST_MOVE_IMPLEMENTATION: Move aware containers from boost::container.
 +-----------------------------------------------------------------------------*/
 
 #if defined(ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION)
-#define ICL_IMPL_SPACE boost::interprocess
+#   define ICL_IMPL_SPACE boost::interprocess
 #elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
-#define ICL_IMPL_SPACE boost::container
+#   define ICL_IMPL_SPACE boost::container
+#   define BOOST_ICL_IS_MOVE_AWARE
 #else
-#define ICL_IMPL_SPACE std
+#   define ICL_IMPL_SPACE std
 #endif
 
 #endif // BOOST_ICL_IMPL_CONFIG_HPP_JOFA_091225

Modified: trunk/boost/icl/interval_base_map.hpp
==============================================================================
--- trunk/boost/icl/interval_base_map.hpp	(original)
+++ trunk/boost/icl/interval_base_map.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -192,7 +192,12 @@
 
     BOOST_STATIC_CONSTANT(int, fineness = 0); 
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    BOOST_COPYABLE_AND_MOVABLE(interval_base_map)
+#   endif
+
 public:
+
     //==========================================================================
     //= Construct, copy, destruct
     //==========================================================================
@@ -214,12 +219,40 @@
         BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
     }
 
-    /** Assignment operator */
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    /** Move constructor */
+    interval_base_map(BOOST_RV_REF(interval_base_map) src): _map(boost::move(src._map))
+    {
+        std::cout << "."; //CL
+        BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
+        BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+        BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<CodomainT>));
+        BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
+    }
+
+    /** Copy assignment operator */
+    interval_base_map& operator = (BOOST_COPY_ASSIGN_REF(interval_base_map) src) 
+    { 
+        this->_map = src._map;
+        return *this; 
+    }
+
+    /** Move assignment operator */
+    interval_base_map& operator = (BOOST_RV_REF(interval_base_map) src) 
+    { 
+        std::cout << ":"; //CL
+        this->_map = boost::move(src._map);
+        return *this; 
+    }
+#   else //BOOST_ICL_IS_MOVE_AWARE
+
+    /** Copy assignment operator */
     interval_base_map& operator = (const interval_base_map& src) 
     { 
         this->_map = src._map;
         return *this; 
     }
+#   endif //BOOST_ICL_IS_MOVE_AWARE
 
     /** swap the content of containers */
     void swap(interval_base_map& object) { _map.swap(object._map); }

Modified: trunk/boost/icl/interval_base_set.hpp
==============================================================================
--- trunk/boost/icl/interval_base_set.hpp	(original)
+++ trunk/boost/icl/interval_base_set.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -15,6 +15,7 @@
 #include <boost/interprocess/containers/set.hpp>
 #elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
 #include <boost/container/set.hpp>
+#include <boost/move/move.hpp> //MOV JODO URG
 #else 
 #include <set>
 #endif

Modified: trunk/boost/icl/interval_map.hpp
==============================================================================
--- trunk/boost/icl/interval_map.hpp	(original)
+++ trunk/boost/icl/interval_map.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -68,15 +68,26 @@
 
     enum { fineness = 1 };
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    BOOST_COPYABLE_AND_MOVABLE(interval_map)
+#   endif
+
 public:
     //==========================================================================
     //= Construct, copy, destruct
     //==========================================================================
+
     /// Default constructor for the empty object
     interval_map(): base_type() {}
+
     /// Copy constructor
     interval_map(const interval_map& src): base_type(src) {}
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    /// Move constructor
+    interval_map(BOOST_RV_REF(interval_map) src)
+        : base_type(boost::move(static_cast<base_type&>(src))){}
+#   endif //BOOST_ICL_IS_MOVE_AWARE
 
     /// Copy constructor for base_type
     template<class SubType>
@@ -106,7 +117,6 @@
         typedef interval_base_map<SubType,DomainT,CodomainT,
                                   Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
         this->clear();
-        // Can be implemented via _map.insert: Interval joining not necessary.
         iterator prior_ = this->_map.end();
         ICL_const_FORALL(typename base_map_type, it_, src) 
             prior_ = this->add(prior_, *it_); 

Modified: trunk/boost/icl/map.hpp
==============================================================================
--- trunk/boost/icl/map.hpp	(original)
+++ trunk/boost/icl/map.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -13,11 +13,12 @@
 #if defined(ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION)
 #include <boost/interprocess/containers/map.hpp>
 #include <boost/interprocess/containers/set.hpp>
-#include <boost/interprocess/containers/flat_set.hpp> //FLAS
+#include <boost/interprocess/containers/flat_set.hpp> //FLAS JODO URG
 #include <boost/interprocess/containers/flat_map.hpp> //FLAS
 #elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
 #include <boost/container/map.hpp>
 #include <boost/container/set.hpp>
+#include <boost/move/move.hpp> //MOV JODO URG <boost/icl/move.hpp>
 #else 
 #include <map>
 #include <set>
@@ -157,6 +158,10 @@
 
     BOOST_STATIC_CONSTANT(int, fineness = 4); 
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    BOOST_COPYABLE_AND_MOVABLE(map)
+#   endif
+
 public:
     //==========================================================================
     //= Construct, copy, destruct
@@ -189,12 +194,44 @@
         BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
     }
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    map(BOOST_RV_REF(map) src)
+        : base_type(boost::move(static_cast<base_type&>(src)))
+    {
+        std::cout << "m.";//CL
+        BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
+        BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+        BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<CodomainT>));
+        BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
+    }
+#   endif //BOOST_ICL_IS_MOVE_AWARE
+
     explicit map(const element_type& key_value_pair): base_type::map()
     { 
         insert(key_value_pair); 
     }
 
-    map& operator=(const map& src) { base_type::operator=(src); return *this; } 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    map& operator=(BOOST_RV_REF(map) src) 
+    { 
+        std::cout << "m=";//CL
+        base_type::operator=(static_cast<base_type&>(src));
+        return *this; 
+    } 
+
+    map& operator=(BOOST_COPY_ASSIGN_REF(map) src) 
+    { 
+        base_type::operator=(static_cast<const base_type&>(src));
+        return *this; 
+    } 
+#   else
+    map& operator=(const map& src) 
+    { 
+        base_type::operator=(static_cast<const base_type&>(src));
+        return *this; 
+    } 
+#   endif //BOOST_ICL_IS_MOVE_AWARE
+
     void swap(map& src) { base_type::swap(src); }
 
     //==========================================================================

Modified: trunk/boost/icl/split_interval_map.hpp
==============================================================================
--- trunk/boost/icl/split_interval_map.hpp	(original)
+++ trunk/boost/icl/split_interval_map.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -62,35 +62,53 @@
 
     enum { fineness = 3 };
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    BOOST_COPYABLE_AND_MOVABLE(split_interval_map)
+#   endif
+
 public:
     //==========================================================================
     //= Construct, copy, destruct
     //==========================================================================
     /// Default constructor for the empty object
     split_interval_map(): base_type() {}
+
     /// Copy constructor
     split_interval_map(const split_interval_map& src): base_type(src) {}
 
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    /// Move constructor
+    split_interval_map(BOOST_RV_REF(split_interval_map) src)
+        : base_type(boost::move(static_cast<base_type&>(src))){}
+#   endif
+
     explicit split_interval_map(domain_mapping_type& base_pair): base_type()
     { this->add(base_pair); }
 
     explicit split_interval_map(const value_type& value_pair): base_type()
     { this->add(value_pair); }
 
-    /// Assignment operator
+    /// Copy assignment operator
     template<class SubType>
     split_interval_map& operator =
         (const interval_base_map<SubType,DomainT,CodomainT,
                                  Traits,Compare,Combine,Section,Interval,Alloc>& src)
     { this->assign(src); return *this; }
 
+
     /// Assignment from a base interval_map.
     template<class SubType>
     void assign(const interval_base_map<SubType,DomainT,CodomainT,
                                         Traits,Compare,Combine,Section,Interval,Alloc>& src)
     {
         this->clear();
-        this->_map.insert(src.begin(), src.end());
+        this->_map.insert(src.begin(), src.end()); //JODO URG new boost.container compiler problem
+        /*hack
+        typedef typename
+        interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> src_type;
+        ICL_const_FORALL(src_type, it_, src)
+            this->insert(*it_);
+        */
     }
 
 private:

Modified: trunk/boost/icl/type_traits/is_numeric.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_numeric.hpp	(original)
+++ trunk/boost/icl/type_traits/is_numeric.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -10,6 +10,7 @@
 
 #include <limits>
 #include <complex>
+#include <functional>
 #include <boost/type_traits/is_floating_point.hpp>
 #include <boost/type_traits/ice.hpp>
 #include <boost/type_traits/is_integral.hpp>

Modified: trunk/libs/icl/test/fastest_interval_map_cases.hpp
==============================================================================
--- trunk/libs/icl/test/fastest_interval_map_cases.hpp	(original)
+++ trunk/libs/icl/test/fastest_interval_map_cases.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -92,6 +92,10 @@
 (fastest_icl_interval_map_intersects_4_bicremental_types)
 {            interval_map_intersects_4_bicremental_types<INTERVAL_MAP, bicremental_type_3, int>();}
 
+BOOST_AUTO_TEST_CASE
+(fastest_icl_interval_map_move_4_bicremental_types)
+{            interval_map_move_4_bicremental_types<INTERVAL_MAP, bicremental_type_1, double>();}
+
 
 #endif // BOOST_ICL_FASTEST_INTERVAL_MAP_CASES_HPP_JOFA_090702
 

Modified: trunk/libs/icl/test/test_casual_/test_casual.cpp
==============================================================================
--- trunk/libs/icl/test/test_casual_/test_casual.cpp	(original)
+++ trunk/libs/icl/test/test_casual_/test_casual.cpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -41,14 +41,14 @@
 
 void pass_it(shared_ptr<int> pi)
 {
-	*pi = 41;
-	cout << "uses: " << pi.use_count() << " cont: " << *pi << endl;
+    *pi = 41;
+    cout << "uses: " << pi.use_count() << " cont: " << *pi << endl;
 }
 
 void pass_it_ref(shared_ptr<int>& pi)
 {
-	*pi = 43;
-	cout << "uses: " << pi.use_count() << " cont: " << *pi << endl;
+    *pi = 43;
+    cout << "uses: " << pi.use_count() << " cont: " << *pi << endl;
 }
 
 BOOST_AUTO_TEST_CASE(casual)
@@ -59,10 +59,10 @@
     typedef interval_set<T>                     IntervalSetT;
     typedef IntervalMapT::interval_type         IntervalT;
 
-	shared_ptr<int> pi(new int(42));
-	cout << "uses: " << pi.use_count() << " cont: " << *pi << endl;
-	pass_it(pi);
-	pass_it_ref(pi);
+    shared_ptr<int> pi(new int(42));
+    cout << "uses: " << pi.use_count() << " cont: " << *pi << endl;
+    pass_it(pi);
+    pass_it_ref(pi);
 
     BOOST_CHECK_EQUAL(true, true);
 }
@@ -76,9 +76,9 @@
 
     Value const max(Limits::max());
 
-	Interval::interval_type piff = Interval::open(max,     max);
+    Interval::interval_type piff = Interval::open(max,     max);
 
-	BOOST_CHECK(!icl::is_empty(Interval::open(max - 2, max)));
+    BOOST_CHECK(!icl::is_empty(Interval::open(max - 2, max)));
     BOOST_CHECK( icl::is_empty(Interval::open(max - 1, max)));
     BOOST_CHECK( icl::is_empty(Interval::open(max,     max)));
 }

Modified: trunk/libs/icl/test/test_icl_map.hpp
==============================================================================
--- trunk/libs/icl/test/test_icl_map.hpp	(original)
+++ trunk/libs/icl/test/test_icl_map.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -43,6 +43,21 @@
 
     //BOOST_CHECK_EQUAL( found == map_a.end(), true );
     //BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
+
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+
+    cout << ">"; //JODO
+    MapT map_b(boost::move(MapT().add(key_value_pair)));
+    cout << "<\n";
+    cout << map_b << endl;
+
+    cout << ">"; 
+    MapT map_c;
+    map_c = boost::move(MapT().add(key_value_pair));
+    cout << "<\n";
+    cout << map_c << endl;
+
+#   endif //BOOST_ICL_IS_MOVE_AWARE
 }
 
 

Modified: trunk/libs/icl/test/test_interval_map_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_map_shared.hpp	(original)
+++ trunk/libs/icl/test/test_interval_map_shared.hpp	2011-12-05 17:59:49 EST (Mon, 05 Dec 2011)
@@ -1516,5 +1516,34 @@
 }
 
 
+template 
+<
+#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
+    ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
+#else
+    ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
+#endif
+    class T, class U
+>
+void interval_map_move_4_bicremental_types()
+{
+    typedef IntervalMap<T,U> IntervalMapT;
+    typedef typename IntervalMapT::interval_type   IntervalT;
+
+#   ifdef BOOST_ICL_IS_MOVE_AWARE
+    IntervalMapT map_A(boost::move(static_cast<IntervalMapT&>(IntervalMapT(IDv(0,4,2)))));
+    IntervalMapT map_B(boost::move(static_cast<IntervalMapT&>(IntervalMapT(IDv(0,2,1)).add(IDv(2,4,1)).add(IDv(0,4,1)))));
+
+    BOOST_CHECK_EQUAL( map_A, map_B );
+
+    map_A = boost::move(static_cast<IntervalMapT&>(IntervalMapT(IIv(1,4,2)))); //JODO not yet moving
+    map_B = boost::move(static_cast<IntervalMapT&>(IntervalMapT(CIv(0,2,1)).insert(IDv(3,5,1)).add(CDv(0,5,1))));
+
+    BOOST_CHECK_EQUAL( map_A, map_B );
+#   endif //BOOST_ICL_IS_MOVE_AWARE
+}
+
+
+
 #endif // LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005