Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r50699 - in sandbox/itl: boost/itl boost/itl/type_traits libs/itl/test libs/itl/test/test_interval_map_mixed libs/itl/test/test_quantifier_map
From: afojgo_at_[hidden]
Date: 2009-01-21 08:34:45


Author: jofaber
Date: 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
New Revision: 50699
URL: http://svn.boost.org/trac/boost/changeset/50699

Log:
Refactored. Rewriting op &= for IntervalMaps after Problems with .&. overloading.
Next: Introduce IntervalMaps::domain_mapping_type and interval_mapping_type.
Stable {msvc-9.0, partly congcc-4.3-a7}

Text files modified:
   sandbox/itl/boost/itl/interval_base_map.hpp | 2
   sandbox/itl/boost/itl/interval_base_set.hpp | 2
   sandbox/itl/boost/itl/interval_map.hpp | 1
   sandbox/itl/boost/itl/interval_maps.hpp | 333 ++++++++++++++++++++++++---------------
   sandbox/itl/boost/itl/interval_set.hpp | 2
   sandbox/itl/boost/itl/operators.hpp | 2
   sandbox/itl/boost/itl/separate_interval_set.hpp | 1
   sandbox/itl/boost/itl/split_interval_map.hpp | 2
   sandbox/itl/boost/itl/split_interval_set.hpp | 1
   sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 42 ++++
   sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp | 1
   sandbox/itl/libs/itl/test/test_laws.hpp | 1
   sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp | 2
   sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 69 ++++----
   14 files changed, 288 insertions(+), 173 deletions(-)

Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -167,6 +167,8 @@
                               itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
                               neutron_absorber_type;
 
+ typedef type overloadable_type;
+
     /// Domain type (type of the keys) of the map
     typedef DomainT domain_type;
     /// Domain type (type of the keys) of the map

Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -119,6 +119,8 @@
     /// The designated \e derived or \e sub_type of this base class
     typedef SubType sub_type;
 
+ typedef type overloadable_type;
+
     /// The domain type of the set
     typedef DomainT domain_type;
     /// The codomaintype is the same as domain_type

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -127,6 +127,7 @@
     typedef Traits traits;
     typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
     typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> split_type;
+ typedef type overloadable_type;
     typedef type joint_type;
     typedef interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
                                DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;

Modified: sandbox/itl/boost/itl/interval_maps.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_maps.hpp (original)
+++ sandbox/itl/boost/itl/interval_maps.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -52,31 +52,7 @@
     return object;
 }
 
-/*CL?
-template
-<
- class SubType, class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
- template
- <
- class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
- >
- class IntervalMap
->
-interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator +
-(
- const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
-)
-{
- typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) += operand;
-}
-*/
 //-----------------------------------------------------------------------------
-
 template
 <
     class DomainT, class CodomainT, class Traits,
@@ -103,31 +79,6 @@
     return object;
 }
 
-/*CL?
-template
-<
- class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
- template
- <
- class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
- >
- class IntervalMap
->
-IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator +
-(
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
-)
-{
- typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) += operand;
-}
-*/
-//-----------------------------------------------------------------------------
-
 //--- value_type --------------------------------------------------------------
 template
 <
@@ -151,63 +102,6 @@
     return object.add(operand);
 }
 
-/*CL
-template
-<
- class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
- template
- <
- class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
- >
- class IntervalMap
->
-IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator +
-(
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
-)
-{
- typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) += operand;
-}
-
-template
-<
- class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
- template
- <
- class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
- >
- class IntervalMap
->
-IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator +
-(
- const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand,
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object
-)
-{
- typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) += operand;
-}
-*/
-/*CL
-template<class ObjectT>
-ObjectT operator + (const ObjectT& object, const typename ObjectT::value_type& operand)
-{ return ObjectT(object) += operand; }
-
-template<class ObjectT>
-ObjectT operator + (const typename ObjectT::value_type& operand, const ObjectT& object)
-{ return ObjectT(object) += operand; }
-*/
-
-//-----------------------------------------------------------------------------
-
 //--- mapping_type ------------------------------------------------------------
 // Addition (+=) of a base value pair.
 /* Addition of an value pair <tt>x=(I,y)</tt>
@@ -244,31 +138,6 @@
 {
     return object.add(operand);
 }
-
-/*
-template
-<
- class DomainT, class CodomainT, class Traits,
-
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
- template
- <
- class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
- >
- class IntervalMap
->
-IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator +
-(
- const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
- const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
-)
-{
- typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) += operand;
-}
-*/
 //-----------------------------------------------------------------------------
 
 
@@ -808,8 +677,209 @@
 }
 
 //-----------------------------------------------------------------------------
+// intersection &=
+//-----------------------------------------------------------------------------
+template
+<
+ class ObjectT,
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+ObjectT& operator &=
+(
+ ObjectT& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
+)
+{
+ typedef ObjectT object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+//-----------------------------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
+operator &=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+//--- value_type --------------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
+operator &=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+//--- mapping_type ------------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
+operator &=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+//--- interval_type ------------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
+operator &=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+//--- element_type ------------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
+operator &=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::domain_type& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+//--- set_types ------------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT, class Traits,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class,
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalMap,
+ template
+ <
+ class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
+operator &=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+ const IntervalSet<DomainT,Compare,Interval,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Compare,Combine,Section,Interval,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+
+
+
+
+//-----------------------------------------------------------------------------
 // intersection *=
 //-----------------------------------------------------------------------------
+/*CL?
 template
 <
     class SubType, class DomainT, class CodomainT, class Traits,
@@ -875,6 +945,7 @@
     object.swap(intersection);
     return object;
 }
+*/
 
 template
 <

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -118,6 +118,8 @@
                               DomainT,Compare,Interval,Alloc> base_type;
 
     typedef interval_set<DomainT,Compare,Interval,Alloc> type;
+ typedef type overloadable_type;
+
     typedef type joint_type;
 
     /// The domain type of the set

Modified: sandbox/itl/boost/itl/operators.hpp
==============================================================================
--- sandbox/itl/boost/itl/operators.hpp (original)
+++ sandbox/itl/boost/itl/operators.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -46,7 +46,7 @@
 { return ObjectT(object) &= operand; }
 
 template<class ObjectT>
-ObjectT operator & (const typename ObjectT::type& object, const ObjectT& operand)//JODO: inhibit false overloads!
+ObjectT operator & (const typename ObjectT::overloadable_type& object, const ObjectT& operand)
 { return ObjectT(object) &= operand; }
 
 }} // namespace itl boost

Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -82,6 +82,7 @@
                               DomainT,Compare,Interval,Alloc> base_type;
 
     typedef separate_interval_set<DomainT,Compare,Interval,Alloc> type;
+ typedef type overloadable_type;
 
     typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
 

Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -143,6 +143,8 @@
         typedef Traits traits;
         typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
         typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> joint_type;
+ typedef type overloadable_type;
+
         typedef interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
                                    DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
 

Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -102,6 +102,7 @@
 
         typedef split_interval_set<DomainT,Compare,Interval,Alloc> type;
         typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
+ typedef type overloadable_type;
 
         /// The domain type of the set
         typedef DomainT domain_type;

Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -10,27 +10,44 @@
 
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <boost/itl/type_traits/is_interval_splitter.hpp>
 
 namespace boost{namespace itl
 {
 
+template<class Type>
+struct is_overloadable
+{
+ enum { value = is_same<Type, typename Type::overloadable_type>::value };
+};
+
+
+
 template<class Type, class AssociateT>
 struct is_combinable;
 
 template<class Type>
-struct is_combinable<Type, typename Type::value_type> { enum{ value = true }; };
+struct is_combinable<Type, typename Type::value_type>
+{ enum{ value = is_overloadable<Type>::value }; };
+
 template<class Type>
-struct is_combinable<Type, typename Type::mapping_pair_type>{ enum{ value = true }; };
+struct is_combinable<Type, typename Type::mapping_pair_type>
+{ enum{ value = is_overloadable<Type>::value }; };
+
 template<class Type>
-struct is_combinable<Type, typename Type::base_type> { enum{ value = true }; };
+struct is_combinable<Type, typename Type::base_type>
+{ enum{ value = is_overloadable<Type>::value }; };
+
 template<class Type>
-struct is_combinable<Type, typename Type::joint_type> { enum{ value = true }; };
+struct is_combinable<Type, typename Type::joint_type>
+{ enum{ value = is_overloadable<Type>::value }; };
 
 template<class Type>
 struct is_combinable<Type, typename Type::separate_type>
 {
- enum{ value = is_interval_splitter<Type>::value };
+ enum{ value = mpl::and_<is_interval_splitter<Type>, is_overloadable<Type> >::value };
 };
 
 template<class Type, class AssociateT>
@@ -39,6 +56,21 @@
         enum{ value = false };
 };
 
+/*
+template<class Type, class AssociateT>
+struct is_combinable2;
+
+template<class Type>
+struct is_combinable2<Type, typename Type::interval_type>
+{ enum{ value = is_overloadable<Type>::value }; };
+
+template<class Type, class AssociateT>
+struct is_combinable2
+{
+ enum{ value = is_combinable2<Type, AssociateT>::value };
+};
+*/
+
 }} // namespace itl boost
 
 #endif

Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -783,6 +783,7 @@
     std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
     std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
     std::pair<interval<T>,U> I1_8D_1(I1_8D, u1);
+ //typename SplitIntervalMapT::value_type I1_8D_1(I1_8D, u1);
     std::pair<interval<T>,U> I2_7D_1(I2_7D, u1);
     std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
     std::pair<interval<T>,U> I2_3D_3(I2_3D, u3);

Modified: sandbox/itl/libs/itl/test/test_laws.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_laws.hpp (original)
+++ sandbox/itl/libs/itl/test/test_laws.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -154,6 +154,7 @@
 DEFINE_MONOID_CHECK_WRT_EQUAL(et);
 
 #define CHECK_MONOID_WRT(op_tag) check_monoid_wrt_##op_tag
+#define CHECK_MONOID_WRT_EQUAL(op_tag) check_monoid_wrt_equal_##op_tag
 
 
 #endif // __test_itl_laws_h_JOFA_080920__

Modified: sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -12,5 +12,5 @@
 
 BOOST_AUTO_TEST_CASE_TEMPLATE
 (test_itl_quantifier_map_check_monoid_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_4_bicremental_types<T, std::string, neutron_emitter>();}
+{ quantifier_map_check_monoid_4_bicremental_types<T, int, neutron_emitter>();}
 

Modified: sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp 2009-01-21 08:34:43 EST (Wed, 21 Jan 2009)
@@ -93,9 +93,6 @@
 const typename JointMapT::value_type& val_pair, const mapping_pair<T,U>& map_pair
 )
 {
- typedef interval_map<T,U> IntervalMapT;
- typedef split_interval_map<T,U> SplitIntervalMapT;
-
         //-----------------------------------------------------------------------------
         CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), join_map_a, join_map_b, val_pair);
         CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), join_map_a, val_pair, join_map_b);
@@ -104,24 +101,25 @@
         CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), join_map_c, map_pair, join_map_b);
 
         //-----------------------------------------------------------------------------
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_a, split_map_b, val_pair);
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_a, val_pair, split_map_b);
+ CHECK_MONOID_WRT(plus)(neutron<SplitMapT>::value(), split_map_a, split_map_b, val_pair);
+ CHECK_MONOID_WRT(plus)(neutron<SplitMapT>::value(), split_map_a, val_pair, split_map_b);
 
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_c, split_map_b, map_pair);
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_c, map_pair, split_map_b);
+ CHECK_MONOID_WRT(plus)(neutron<SplitMapT>::value(), split_map_c, split_map_b, map_pair);
+ CHECK_MONOID_WRT(plus)(neutron<SplitMapT>::value(), split_map_c, map_pair, split_map_b);
 
         //-----------------------------------------------------------------------------
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_a, join_map_b, split_map_c);
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_a, split_map_b, join_map_c);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, join_map_b, split_map_c);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, split_map_b, join_map_c);
+
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, join_map_b, join_map_c);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, join_map_b, join_map_c);
 
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_a, join_map_b, join_map_c);
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_a, join_map_b, join_map_c);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, join_map_b, map_pair);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, map_pair, join_map_b);
 
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_c, join_map_b, map_pair);
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_c, map_pair, join_map_b);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, join_map_b, val_pair);
+ CHECK_MONOID_WRT_EQUAL(plus)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, val_pair, join_map_b);
 
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_c, join_map_b, val_pair);
- CHECK_MONOID_WRT(plus)(neutron<JointMapT>::value(), split_map_c, val_pair, join_map_b);
 }
 
 
@@ -133,9 +131,6 @@
 const typename JointMapT::value_type& val_pair, const mapping_pair<T,U>& map_pair
 )
 {
- typedef interval_map<T,U> IntervalMapT;
- typedef split_interval_map<T,U> SplitIntervalMapT;
-
         //-----------------------------------------------------------------------------
         CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), join_map_a, join_map_b, val_pair);
         CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), join_map_a, val_pair, join_map_b);
@@ -144,24 +139,25 @@
         CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), join_map_c, map_pair, join_map_b);
 
         //-----------------------------------------------------------------------------
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_a, split_map_b, val_pair);
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_a, val_pair, split_map_b);
+ CHECK_MONOID_WRT(et)(neutron<SplitMapT>::value(), split_map_a, split_map_b, val_pair);
+ CHECK_MONOID_WRT(et)(neutron<SplitMapT>::value(), split_map_a, val_pair, split_map_b);
 
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_c, split_map_b, map_pair);
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_c, map_pair, split_map_b);
+ CHECK_MONOID_WRT(et)(neutron<SplitMapT>::value(), split_map_c, split_map_b, map_pair);
+ CHECK_MONOID_WRT(et)(neutron<SplitMapT>::value(), split_map_c, map_pair, split_map_b);
 
         //-----------------------------------------------------------------------------
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_a, join_map_b, split_map_c);
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_a, split_map_b, join_map_c);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, join_map_b, split_map_c);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, split_map_b, join_map_c);
 
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_a, join_map_b, join_map_c);
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_a, join_map_b, join_map_c);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, join_map_b, join_map_c);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_a, join_map_b, join_map_c);
 
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_c, join_map_b, map_pair);
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_c, map_pair, join_map_b);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, join_map_b, map_pair);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, map_pair, join_map_b);
+
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, join_map_b, val_pair);
+ CHECK_MONOID_WRT_EQUAL(et)(is_element_equal, neutron<SplitMapT>::value(), split_map_c, val_pair, join_map_b);
 
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_c, join_map_b, val_pair);
- CHECK_MONOID_WRT(et)(neutron<JointMapT>::value(), split_map_c, val_pair, join_map_b);
 }
 
 template <class T, class U, class Trait>
@@ -175,7 +171,7 @@
         join_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
         join_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
 
- IntervalMapT split_map_a, split_map_b, split_map_c;
+ SplitIntervalMapT split_map_a, split_map_b, split_map_c;
         split_map_a.add(IDv(0,6,2)).add(IDv(5,7,1)).add(IDv(9,10,2));
         split_map_b.add(IDv(2,3,3)).add(IIv(9,9,3)).add(CDv(9,11,2));
         split_map_c.add(CIv(0,9,2)).add(IIv(3,6,1)).add(CDv(5,7,1));
@@ -189,12 +185,15 @@
                 split_map_a, split_map_b, split_map_c,
                 val_pair, map_pair);
 
- //quantifier_map_check_monoid_instance_et(
- // join_map_a, join_map_b, join_map_c,
- // split_map_a, split_map_b, split_map_c,
- // val_pair, map_pair);
+ quantifier_map_check_monoid_instance_et(
+ join_map_a, join_map_b, join_map_c,
+ split_map_a, split_map_b, split_map_c,
+ val_pair, map_pair);
+
+
 }
 
 
+
 #endif // __test_itl_quantifier_map_shared_h_JOFA_090119__
 


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