Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r67353 - in sandbox/icl/libs/icl: example example/boost_party_ example/party_ test test/test_combinable_
From: afojgo_at_[hidden]
Date: 2010-12-19 14:11:39

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r67354 - sandbox/chrono/boost/static_integer"
Previous message: mr.chr.schmidt_at_[hidden]: "[Boost-commit] svn:boost r67352 - trunk/boost/fusion/sequence/intrinsic"

Author: jofaber
Date: 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
New Revision: 67353
URL: http://svn.boost.org/trac/boost/changeset/67353

Log:
Merged trunk version of boost/icl and libs/icl to sandbox version. Except for html-files.
Added:
   sandbox/icl/libs/icl/test/portability.hpp
      - copied unchanged from r67349, /trunk/libs/icl/test/portability.hpp
Properties modified:
   sandbox/icl/libs/icl/example/ (props changed)
   sandbox/icl/libs/icl/test/ (props changed)
Text files modified:
   sandbox/icl/libs/icl/example/boost_party_/boost_party.cpp | 4
   sandbox/icl/libs/icl/example/party_/party.cpp | 10 -
   sandbox/icl/libs/icl/test/Jamfile.v2 | 3
   sandbox/icl/libs/icl/test/fastest_partial_icl_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/fastest_partial_interval_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/fastest_total_icl_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/fastest_total_interval_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/test_combinable_/test_combinable.cpp | 1
   sandbox/icl/libs/icl/test/test_functions.hpp | 31 +---
   sandbox/icl/libs/icl/test/test_icl_dynamic_interval.hpp | 6
   sandbox/icl/libs/icl/test/test_icl_map.hpp | 39 +-----
   sandbox/icl/libs/icl/test/test_icl_quantifier_shared.hpp | 121 ++++---------------
   sandbox/icl/libs/icl/test/test_interval_map_mixed.hpp | 6
   sandbox/icl/libs/icl/test/test_interval_map_shared.hpp | 220 ++++--------------------------------
   sandbox/icl/libs/icl/test/test_interval_quantifier_shared.hpp | 133 ++++------------------
   sandbox/icl/libs/icl/test/test_interval_set_laws_shared.hpp | 80 +++----------
   sandbox/icl/libs/icl/test/test_interval_set_mixed.hpp | 12 +-
   sandbox/icl/libs/icl/test/test_interval_set_shared.hpp | 148 +++++-------------------
   sandbox/icl/libs/icl/test/test_laws.hpp | 240 ++++++++++++++++++++--------------------
   sandbox/icl/libs/icl/test/test_partial_icl_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/test_partial_interval_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/test_quantifier_icl_map.hpp | 96 +++-------------
   sandbox/icl/libs/icl/test/test_quantifier_map_shared.hpp | 96 +++-------------
   sandbox/icl/libs/icl/test/test_set_icl_set.hpp | 49 +------
   sandbox/icl/libs/icl/test/test_set_interval_set_shared.hpp | 94 +++------------
   sandbox/icl/libs/icl/test/test_total_icl_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/test_total_interval_quantifier_cases.hpp | 6
   sandbox/icl/libs/icl/test/test_type_lists.hpp | 33 ++++-
   sandbox/icl/libs/icl/test/test_value_maker.hpp | 65 +++++++---
   29 files changed, 445 insertions(+), 1090 deletions(-)

Modified: sandbox/icl/libs/icl/example/boost_party_/boost_party.cpp
==============================================================================
--- sandbox/icl/libs/icl/example/boost_party_/boost_party.cpp (original)
+++ sandbox/icl/libs/icl/example/boost_party_/boost_party.cpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -31,11 +31,11 @@
     time, where the group of party guests changed.

     boost_party.cpp demonstrates a principle that we call
- <b><em>aggregate on overlap (aggrovering;)</em></b>:
+ <b><em>aggregate on overlap</em></b>:
     On insertion a value associated to the interval is aggregated (added) to those
     values in the interval_map that overlap with the inserted value.

- There are two behavioral aspects to <b>aggrovering</b>: a <em>decompositional
+ There are two behavioral aspects to <b>aggregate on overlap</b>: a <em>decompositional
     behavior</em> and a <em>accumulative behavior</em>.

     The <em>decompositional behavior</em> splits up intervals on the time dimension of the

Modified: sandbox/icl/libs/icl/example/party_/party.cpp
==============================================================================
--- sandbox/icl/libs/icl/example/party_/party.cpp (original)
+++ sandbox/icl/libs/icl/example/party_/party.cpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,7 +1,7 @@
/*-----------------------------------------------------------------------------+
Interval Container Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2009: Joachim Faulhaber
+Copyright (c) 2007-2010: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
@@ -16,7 +16,6 @@
using namespace boost::icl;

/**
-
     Party.cpp demonstrates the possibilities of an interval map (interval_map or
     split_interval_map). An interval_map maps intervals to a given content. In
     this case the content is a set of party guests represented by their name
@@ -49,7 +48,6 @@

     The accumulative behavior accumulates associated values on every overlap of
     an insertion for the associated values.
-
*/

// Type set<string> collects the names of party guests. Since std::set is
@@ -57,7 +55,7 @@
// that performs a set union on overlap of intervals.
typedef std::set<string> GuestSetT;

-// Time is the domain type the split_interval_map. It's key values are therefore
+// 'Time' is the domain type the interval_map. It's key values are therefore
// time intervals. The content is the set of names: GuestSetT.

@@ -76,10 +74,6 @@

     interval_map<Time, GuestSetT> party;

- //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);
-
     party += make_pair( interval<Time>::right_open(Time(19,30), Time(23,00)), mary_harry);
     party += make_pair( interval<Time>::right_open(Time(20,10), Time(monday,0,0)), diana_susan);
     party += make_pair( interval<Time>::right_open(Time(22,15), Time(monday,0,30)), peter);

Modified: sandbox/icl/libs/icl/test/Jamfile.v2
==============================================================================
--- sandbox/icl/libs/icl/test/Jamfile.v2 (original)
+++ sandbox/icl/libs/icl/test/Jamfile.v2 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -56,6 +56,7 @@
       [ run test_misc_/test_misc.cpp ]
       [ run test_doc_code_/test_doc_code.cpp ]
       [ run test_type_traits_/test_type_traits.cpp ]
- [ run test_combinable_/test_combinable.cpp ]
+ # test_combinable is too slow or too large for some compilers
+ #[ run test_combinable_/test_combinable.cpp ]
       [ run test_changing_interval_defaults_/test_changing_interval_defaults.cpp ]
     ;

Modified: sandbox/icl/libs/icl/test/fastest_partial_icl_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/fastest_partial_icl_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/fastest_partial_icl_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -51,14 +51,14 @@
(fastest_itl_partial_enricher_icl_quantifier_check_abelian_monoid_et_4_bicremental_types)
{ icl_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, int, partial_enricher, INTERVAL_MAP>();}

-// x - x =p= 0 | partial enricher
+// x - x =d= 0 | partial enricher
BOOST_AUTO_TEST_CASE
(fastest_itl_partial_enricher_icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types)
{ icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, partial_enricher, INTERVAL_MAP>();}

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

//------------------------------------------------------------------------------
// Containedness

Modified: sandbox/icl/libs/icl/test/fastest_partial_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/fastest_partial_interval_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/fastest_partial_interval_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -51,14 +51,14 @@
(fastest_itl_partial_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types)
{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, int, partial_enricher, INTERVAL_MAP>();}

-// x - x =p= 0 | partial enricher
+// x - x =d= 0 | partial enricher
BOOST_AUTO_TEST_CASE
(fastest_itl_partial_enricher_itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types)
{ itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, partial_enricher, INTERVAL_MAP>();}

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

//------------------------------------------------------------------------------

Modified: sandbox/icl/libs/icl/test/fastest_total_icl_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/fastest_total_icl_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/fastest_total_icl_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -59,7 +59,7 @@
(fastest_itl_total_enricher_icl_quantifier_check_abelian_monoid_et_4_bicremental_types)
{ icl_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, double, total_enricher, INTERVAL_MAP>();}

-// (0-x) + x =p= 0 | total absorber
+// (0-x) + x =d= 0 | total absorber
BOOST_AUTO_TEST_CASE
(fastest_itl_total_enricher_icl_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_discrete_codomain)
{ icl_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, total_enricher, INTERVAL_MAP>();}
@@ -74,8 +74,8 @@

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

Modified: sandbox/icl/libs/icl/test/fastest_total_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/fastest_total_interval_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/fastest_total_interval_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -59,7 +59,7 @@
(fastest_itl_total_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types)
{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, double, total_enricher, INTERVAL_MAP>();}

-// (0-x) + x =p= 0 | total absorber
+// (0-x) + x =d= 0 | total absorber
BOOST_AUTO_TEST_CASE
(fastest_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_discrete_codomain)
{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, total_enricher, INTERVAL_MAP>();}
@@ -73,8 +73,8 @@
{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_4, boost::rational<int>, total_enricher, INTERVAL_MAP>();}

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

//------------------------------------------------------------------------------

Modified: sandbox/icl/libs/icl/test/test_combinable_/test_combinable.cpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_combinable_/test_combinable.cpp (original)
+++ sandbox/icl/libs/icl/test/test_combinable_/test_combinable.cpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -21,7 +21,6 @@
#include <boost/icl/split_interval_set.hpp>
#include <boost/icl/interval_map.hpp>
#include <boost/icl/split_interval_map.hpp>
-#include <boost/validate/type/nat.hpp>

using namespace std;
using namespace boost;

Modified: sandbox/icl/libs/icl/test/test_functions.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_functions.hpp (original)
+++ sandbox/icl/libs/icl/test/test_functions.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -18,23 +18,18 @@

#include <boost/icl/type_traits/identity_element.hpp>
#include <boost/icl/functors.hpp>
+#include "portability.hpp"
+

namespace boost{namespace icl
{

-template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <class T, class U, class Trt,
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap,
           class SequenceT
>
void itl_map_copy(const SequenceT& segments,
- IntervalMap<T,U,Trt>& destination)
+ ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& destination)
{
     ICL_const_FORALL(typename SequenceT, segment_, segments)
         destination.insert(*segment_);
@@ -42,20 +37,14 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap,
           class SequenceT
>
-void test_interval_map_copy_via_inserter(const SequenceT& segments, IntervalMap<T,U,Trt>& std_copied_map)
+void test_interval_map_copy_via_inserter(const SequenceT& segments,
+ ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& std_copied_map)
{
- // The second parameter (std_copied_map) could be omitted and only held as a
- // local variable. I is there to help gcc-3.4.4 resolving the function template type.
+ // The second parameter (std_copied_map) could be omitted and is only held as a
+ // local variable. It is there to help gcc-3.4.4 resolving the function template type.
     typedef IntervalMap<T,U,Trt> IntervalMapT;
     IntervalMapT looped_copied_map;
     std_copied_map.clear();

Modified: sandbox/icl/libs/icl/test/test_icl_dynamic_interval.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_icl_dynamic_interval.hpp (original)
+++ sandbox/icl/libs/icl/test/test_icl_dynamic_interval.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -28,9 +28,9 @@
{
     typedef typename icl::interval<T>::type IntervalT;

- BOOST_CHECK_EQUAL( T(), pred(succ(T())));
- BOOST_CHECK_EQUAL( icl::identity_element<T>::value(), pred(succ(icl::identity_element<T>::value())) );
- BOOST_CHECK_EQUAL( icl::unit_element<T>::value(), succ(icl::identity_element<T>::value()) );
+ BOOST_CHECK_EQUAL( T(), icl::pred(icl::succ(T())));
+ BOOST_CHECK_EQUAL( icl::identity_element<T>::value(), icl::pred(icl::succ(icl::identity_element<T>::value())) );
+ BOOST_CHECK_EQUAL( icl::unit_element<T>::value(), icl::succ(icl::identity_element<T>::value()) );
     BOOST_CHECK_EQUAL( length(IntervalT()), icl::identity_element<typename difference_type_of<T>::type>::value() );

     //LAW: I x: borders(x)==closed => contains(x, lower(x)) && contains(x, upper(x))

Modified: sandbox/icl/libs/icl/test/test_icl_map.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_icl_map.hpp (original)
+++ sandbox/icl/libs/icl/test/test_icl_map.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,24 +1,17 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_itl_map_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_itl_map_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_ICL_MAP_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_ICL_MAP_HPP_JOFA_090119

+#include "portability.hpp"

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itl_map_contains_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -47,15 +40,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itl_map_find_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -80,15 +65,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itl_map_inclusion_compare_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -155,5 +132,5 @@
}

-#endif // LIBS_ICL_TEST_TEST_ICL_itl_map_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_ICL_MAP_HPP_JOFA_090119

Modified: sandbox/icl/libs/icl/test/test_icl_quantifier_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_icl_quantifier_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_icl_quantifier_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -5,27 +5,20 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __TEST_ICL_QUANTIFIER_SHARED_H_JOFA_100819__
-#define __TEST_ICL_QUANTIFIER_SHARED_H_JOFA_100819__
+#ifndef LIBS_ICL_TEST_TEST_ICL_QUANTIFIER_SHARED_HPP_JOFA_100819
+#define LIBS_ICL_TEST_TEST_ICL_QUANTIFIER_SHARED_HPP_JOFA_100819

+#include "portability.hpp"

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void make_3_icl_maps_and_derivatives_1
                    (icl::map<T,U,Trt>& map_a,
                     icl::map<T,U,Trt>& map_b,
                     icl::map<T,U,Trt>& map_c,
                     std::pair<T,U>& map_pair_a,
                     std::pair<T,U>& map_pair_b,
- IntervalMap<T,U,Trt>*)
+ ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)*)
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
     typedef icl::map<T,U,Trt> MapT;
@@ -67,15 +60,7 @@
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -91,15 +76,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -118,12 +95,12 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
+ template<class _T, class _U,
                    class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
+ ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, _U),
+ ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, _U),
+ ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, _U),
+ ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, _T, Compare),
                    ICL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -142,15 +119,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -169,15 +138,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -192,18 +153,10 @@
}

//------------------------------------------------------------------------------
-// Abelian partial invertive monoid with protonic equality for inversion
+// Abelian partial invertive monoid with distinct equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -216,8 +169,10 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair_a, map_pair_b);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair_a, map_pair_b);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
+#endif
}

@@ -225,15 +180,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -248,23 +195,15 @@
}

//------------------------------------------------------------------------------
-// (0 - x) + x =p= 0
+// (0 - x) + x =d= 0
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
- // check abelian group wrt. + and inverability wrt. protonic equality =p= :
+ // check abelian group wrt. + and inverability wrt. distinct equality =d= :
     // (1) (IntervalMapT, +) is an abelian group and
- // (2) The inverability law: (0 - x) + x =p= 0 holds.
+ // (2) The inverability law: (0 - x) + x =d= 0 holds.
     typedef IntervalMap<T,U,Trt> IntervalMapT;
     typedef icl::map<T,U,Trt> MapT;
     IntervalMapT aux;
@@ -275,23 +214,17 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
+#endif
}

//------------------------------------------------------------------------------
// Containedness
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_containedness_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -311,5 +244,5 @@
}

-#endif // __TEST_ICL_QUANTIFIER_SHARED_H_JOFA_100819__
+#endif // LIBS_ICL_TEST_TEST_ICL_QUANTIFIER_SHARED_HPP_JOFA_100819

Modified: sandbox/icl/libs/icl/test/test_interval_map_mixed.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_interval_map_mixed.hpp (original)
+++ sandbox/icl/libs/icl/test/test_interval_map_mixed.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -19,7 +19,7 @@
     typedef interval_map<T,U> IntervalMapT;
     typedef split_interval_map<T,U> SplitIntervalMapT;

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();
     U u1 = unit_element<U>::value();

     SplitIntervalMapT split_map(make_pair(v0,u1));
@@ -36,7 +36,7 @@
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef typename IntervalMapT::interval_type IntervalT;

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();
     U u1 = unit_element<U>::value();

     SplitIntervalMapT split_empty, split_single(make_pair(v0,u1));
@@ -81,7 +81,7 @@
     typedef split_interval_map<T,U> SplitIntervalMapT;
     typedef typename IntervalMapT::interval_type IntervalT;

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();
     T v1 = unit_element<T>::value();
     U u1 = unit_element<U>::value();

Modified: sandbox/icl/libs/icl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_interval_map_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_interval_map_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -5,17 +5,12 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_interval_map_shared_h_JOFA_081005__
-#define LIBS_ICL_TEST_TEST_ICL_interval_map_shared_h_JOFA_081005__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005
+#define LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+#include "portability.hpp"
+
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_fundamentals_4_ordered_types()
{
@@ -29,8 +24,6 @@
     // we are able to test operations only for the most basic values
     // boost::icl::identity_element (0, empty, T() ...) and unit_element.

- //T v0 = boost::icl::identity_element<T>();
- //T v1 = unit_element<T>();
     T v0 = boost::icl::identity_element<T>::value();
     T v1 = unit_element<T>::value();
     IntervalT I0_0I(v0);
@@ -162,14 +155,7 @@

}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_ctor_4_bicremental_types()
{
@@ -227,14 +213,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_add_sub_4_bicremental_types()
{
@@ -281,14 +260,7 @@
     BOOST_CHECK_EQUAL( map_A2, map_B2 );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_distinct_4_bicremental_types()
{
@@ -316,14 +288,7 @@
     BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_distinct_4_bicremental_continuous_types()
{
@@ -370,14 +335,7 @@

}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_isolate_4_bicremental_continuous_types()
{
@@ -426,14 +384,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_contains_4_bicremental_types()
{
@@ -469,14 +420,7 @@
     BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set2), true );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_contains_key_objects_4_bicremental_types()
{
@@ -511,14 +455,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_operators_4_bicremental_types()
{
@@ -554,14 +491,7 @@

// Test for nontrivial intersection of interval maps with intervals and values
-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_base_intersect_4_bicremental_types()
{
@@ -661,14 +591,7 @@

// Test for nontrivial erasure of interval maps with intervals and interval sets
-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_base_erase_4_bicremental_types()
{
@@ -779,14 +702,7 @@

// Test first_collision
-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_base_is_disjoint_4_bicremental_types()
{
@@ -864,14 +780,7 @@
     BOOST_CHECK_EQUAL( intersects(map_B, set_A), true );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_flip_4_bicremental_types()
{
@@ -892,14 +801,7 @@
     BOOST_CHECK_EQUAL(set_a ^= IDv(1,3,1), IMap(IDv(0,1,1)) + IDv(2,3,1));
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_plus_overload_4_bicremental_types()
{
@@ -920,14 +822,7 @@
     BOOST_CHECK_EQUAL(map_b + map_pair, map_pair + map_b);
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_pipe_overload_4_bicremental_types()
{
@@ -950,14 +845,7 @@

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_minus_overload_4_bicremental_types()
{
@@ -1003,14 +891,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_et_overload_4_bicremental_types()
{
@@ -1053,14 +934,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_caret_overload_4_bicremental_types()
{
@@ -1093,14 +967,7 @@
     BOOST_CHECK_EQUAL(map_b ^ map_pair, map_pair ^ map_b);
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_find_4_bicremental_types()
{
@@ -1126,14 +993,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_set_4_bicremental_types()
{
@@ -1154,15 +1014,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void interval_map_inclusion_compare_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -1226,15 +1078,7 @@
}

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void interval_map_std_copy_via_inserter_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT; //Nedded for the test value generator
@@ -1268,15 +1112,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void interval_map_element_iter_4_discrete_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -1312,5 +1148,5 @@

}

-#endif // LIBS_ICL_TEST_TEST_ICL_interval_map_shared_h_JOFA_080920__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005

Modified: sandbox/icl/libs/icl/test/test_interval_quantifier_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_interval_quantifier_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_interval_quantifier_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -8,22 +8,15 @@
#ifndef __TEST_INTERVAL_QUANTIFIER_SHARED_H_JOFA_090119__
#define __TEST_INTERVAL_QUANTIFIER_SHARED_H_JOFA_090119__

-
+#include "portability.hpp"
+
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void make_3_itv_maps_and_derivatives_1
- (IntervalMap<T,U,Trt>& itv_map_a,
- IntervalMap<T,U,Trt>& itv_map_b,
- IntervalMap<T,U,Trt>& itv_map_c,
- typename IntervalMap<T,U,Trt>::interval_mapping_type& val_pair,
+ (ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& itv_map_a,
+ ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& itv_map_b,
+ ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& itv_map_c,
+ typename ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)::interval_mapping_type& val_pair,
                     mapping_pair<T,U>& map_pair)
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -41,15 +34,7 @@
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -64,15 +49,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -90,15 +67,7 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -113,15 +82,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -139,15 +100,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -161,18 +114,10 @@
}

//------------------------------------------------------------------------------
-// Abelian partial invertive monoid with protonic equality for inversion
+// Abelian partial invertive monoid with distinct equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -184,8 +129,10 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+#endif
}

@@ -193,15 +140,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -215,23 +154,15 @@
}

//------------------------------------------------------------------------------
-// (0 - x) + x =p= 0
+// (0 - x) + x =d= 0
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
- // check abelian group wrt. + and inverability wrt. protonic equality =p= :
+ // check abelian group wrt. + and inverability wrt. distinct equality =d= :
     // (1) (IntervalMapT, +) is an abelian group and
- // (2) The inverability law: (0 - x) + x =p= 0 holds.
+ // (2) The inverability law: (0 - x) + x =d= 0 holds.
     typedef IntervalMap<T,U,Trt> IntervalMapT;
     IntervalMapT map_a, map_b, map_c;
     typename IntervalMapT::interval_mapping_type val_pair;
@@ -241,8 +172,10 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+#endif
}

@@ -250,15 +183,7 @@
// Inner complement
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_inner_complementarity_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -274,15 +199,7 @@
}

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_length_complementarity_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;

Modified: sandbox/icl/libs/icl/test/test_interval_set_laws_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_interval_set_laws_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_interval_set_laws_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,24 +1,18 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_interval_set_laws_shared_h_JOFA_090201__
-#define LIBS_ICL_TEST_TEST_ICL_interval_set_laws_shared_h_JOFA_090201__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_LAWS_SHARED_HPP_JOFA_090201
+#define LIBS_ICL_TEST_TEST_INTERVAL_SET_LAWS_SHARED_HPP_JOFA_090201

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -36,13 +30,7 @@
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -63,13 +51,7 @@
// Abelian monoid EANC
//------------------------------------------------------------------------------

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -87,13 +69,7 @@
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -114,13 +90,7 @@
//------------------------------------------------------------------------------
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -138,15 +108,9 @@
}

//------------------------------------------------------------------------------
-// Abelian partial invertive monoid with protonic equality for inversion
+// Abelian partial invertive monoid with distinct equality for inversion
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -162,21 +126,17 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(set_a, set_b, set_c, segm, elem);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(set_a, set_b, set_c, segm, elem);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, set_a, set_b, set_c, segm, elem);
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, set_a, set_b, set_c, segm, elem);
+#endif
}

//------------------------------------------------------------------------------
// Abelian group EANIC
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -194,15 +154,9 @@
}

//------------------------------------------------------------------------------
-// (0 - x) + x =p= 0 |
+// (0 - x) + x =d= 0 |
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -218,9 +172,11 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, set_a, set_b, set_c, segm, elem);
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, set_a, set_b, set_c, segm, elem);
+#endif
}

-#endif // LIBS_ICL_TEST_TEST_ICL_interval_set_laws_shared_h_JOFA_090201__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_LAWS_SHARED_HPP_JOFA_090201

Modified: sandbox/icl/libs/icl/test/test_interval_set_mixed.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_interval_set_mixed.hpp (original)
+++ sandbox/icl/libs/icl/test/test_interval_set_mixed.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -5,8 +5,8 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __fastest_icl_interval_set_mixed_h_JOFA_090702__
-#define __fastest_icl_interval_set_mixed_h_JOFA_090702__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702
+#define LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702

template <class T>
void interval_set_mixed_ctor_4_ordered_types()
@@ -14,7 +14,7 @@
     typedef interval_set<T> IntervalSetT;
     typedef typename IntervalSetT::interval_type IntervalT;

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();

     split_interval_set<T> split_set(v0);
     separate_interval_set<T> sep_set(split_set);
@@ -30,7 +30,7 @@
     typedef interval_set<T> IntervalSetT;
     typedef typename IntervalSetT::interval_type IntervalT;

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();

     split_interval_set<T> split_empty, split_single(v0);
     separate_interval_set<T> sep_empty, sep_single(v0);
@@ -97,7 +97,7 @@
     typedef interval_set<T> IntervalSetT;
     typedef typename IntervalSetT::interval_type IntervalT;

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();
     T v1 = unit_element<T>::value();

     split_interval_set<T> split_set;
@@ -874,4 +874,4 @@
     BOOST_CHECK_EQUAL(sep_a ^ join_a, join_a ^ sep_a );
}

-#endif // __fastest_icl_interval_set_mixed_h_JOFA_090702__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702

Modified: sandbox/icl/libs/icl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_interval_set_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_interval_set_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,20 +1,16 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_interval_set_shared_h_JOFA_080920__
-#define LIBS_ICL_TEST_TEST_ICL_interval_set_shared_h_JOFA_080920__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_SHARED_HPP_JOFA_080920
+#define LIBS_ICL_TEST_TEST_INTERVAL_SET_SHARED_HPP_JOFA_080920

+#include "portability.hpp"

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_fundamentals_4_ordered_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -27,7 +23,7 @@
     // we are able to test operations only for the most basic values
     // identity_element (0, empty, T() ...) and unit_element.

- T v0 = identity_element<T>::value();
+ T v0 = boost::icl::identity_element<T>::value();
     T v1 = unit_element<T>::value();
     IntervalT I0_0I(v0);
     IntervalT I1_1I(v1);
@@ -38,16 +34,16 @@
     //-------------------------------------------------------------------------
     BOOST_CHECK_EQUAL(IntervalSet<T>().empty(), true);
     BOOST_CHECK_EQUAL(icl::is_empty(IntervalSet<T>()), true);
- BOOST_CHECK_EQUAL(cardinality(IntervalSet<T>()), identity_element<size_T>::value());
- BOOST_CHECK_EQUAL(IntervalSet<T>().size(), identity_element<size_T>::value());
+ BOOST_CHECK_EQUAL(cardinality(IntervalSet<T>()), boost::icl::identity_element<size_T>::value());
+ BOOST_CHECK_EQUAL(IntervalSet<T>().size(), boost::icl::identity_element<size_T>::value());
     BOOST_CHECK_EQUAL(interval_count(IntervalSet<T>()), 0);
     BOOST_CHECK_EQUAL(IntervalSet<T>().iterative_size(), 0);
     BOOST_CHECK_EQUAL(iterative_size(IntervalSet<T>()), 0);
     BOOST_CHECK_EQUAL(IntervalSet<T>(), IntervalSet<T>());

- IntervalT mt_interval = identity_element<IntervalT>::value();
+ IntervalT mt_interval = boost::icl::identity_element<IntervalT>::value();
     BOOST_CHECK_EQUAL(mt_interval, IntervalT());
- IntervalSet<T> mt_set = identity_element<IntervalSet<T> >::value();
+ IntervalSet<T> mt_set = boost::icl::identity_element<IntervalSet<T> >::value();
     BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());

     //adding emptieness to emptieness yields emptieness ;)
@@ -57,7 +53,7 @@
     BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
     (mt_set += mt_interval) += mt_interval;
     BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
- BOOST_CHECK_EQUAL(hull(mt_set), identity_element<IntervalT >::value());
+ BOOST_CHECK_EQUAL(hull(mt_set), boost::icl::identity_element<IntervalT >::value());

     //subtracting emptieness
     mt_set.subtract(mt_interval).subtract(mt_interval);
@@ -146,12 +142,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_ctor_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -201,12 +192,7 @@

}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_add_sub_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -245,12 +231,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_distinct_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -275,12 +256,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_distinct_4_bicremental_continuous_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -317,12 +293,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_isolate_4_bicremental_continuous_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -365,12 +336,8 @@
     BOOST_CHECK_EQUAL( iso_set, iso_set4 );
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_element_compare_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -411,12 +378,7 @@
     BOOST_CHECK_EQUAL( is_element_equal( I_D(0,1)+ISet(I_D(1,4))+I_D(3,4), I_D(0,2)+ISet(I_D(2,4)) ), true );
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_contains_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -452,12 +414,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_operators_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -498,12 +455,7 @@

// Test for nontrivial intersection of interval sets with intervals and values
-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_base_intersect_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -573,12 +525,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_flip_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -613,12 +560,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_plus_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -636,12 +578,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_pipe_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -661,12 +598,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_minus_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -685,12 +617,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_et_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -710,12 +637,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_caret_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -735,12 +657,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_find_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -760,12 +677,7 @@
     BOOST_CHECK_EQUAL( found == set_a.end(), true );
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_element_iter_4_discrete_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -796,5 +708,5 @@
     BOOST_CHECK_EQUAL( vec == dest, true );
}

-#endif // LIBS_ICL_TEST_TEST_ICL_interval_set_shared_h_JOFA_080920__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_SHARED_HPP_JOFA_080920

Modified: sandbox/icl/libs/icl/test/test_laws.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_laws.hpp (original)
+++ sandbox/icl/libs/icl/test/test_laws.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
@@ -58,14 +58,14 @@

// Here we actually generate function templates by calling the defining
// macros.
-DEFINE_ASSOCIATIVITY_CHECK_WRT (plus, + );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus, + );
-DEFINE_ASSOCIATIVITY_CHECK_WRT (pipe, | );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(pipe, | );
-DEFINE_ASSOCIATIVITY_CHECK_WRT (et, & );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(et, & );
-DEFINE_ASSOCIATIVITY_CHECK_WRT (caret, ^ );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(caret, ^ );
+DEFINE_ASSOCIATIVITY_CHECK_WRT (plus, + )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus, + )
+DEFINE_ASSOCIATIVITY_CHECK_WRT (pipe, | )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(pipe, | )
+DEFINE_ASSOCIATIVITY_CHECK_WRT (et, & )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(et, & )
+DEFINE_ASSOCIATIVITY_CHECK_WRT (caret, ^ )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(caret, ^ )

//------------------------------------------------------------------------------
@@ -115,16 +115,16 @@
#define CHECK_NEUTRALITY_WRT(op_tag) check_neutrality_wrt_##op_tag
#define CHECK_NEUTRALITY_WRT_EQUAL(op_tag) check_neutrality_wrt_equal_##op_tag

-DEFINE_NEUTRALITY_CHECK_WRT (plus, + );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(plus, + );
-DEFINE_NEUTRALITY_CHECK_WRT (pipe, | );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(pipe, | );
-DEFINE_NEUTRALITY_CHECK_WRT (minus, - );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(minus, - );
-DEFINE_NEUTRALITY_CHECK_WRT (et, & );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(et, & );
-DEFINE_NEUTRALITY_CHECK_WRT (caret, ^ );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(caret, ^ );
+DEFINE_NEUTRALITY_CHECK_WRT (plus, + )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(plus, + )
+DEFINE_NEUTRALITY_CHECK_WRT (pipe, | )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(pipe, | )
+DEFINE_NEUTRALITY_CHECK_WRT (minus, - )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(minus, - )
+DEFINE_NEUTRALITY_CHECK_WRT (et, & )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(et, & )
+DEFINE_NEUTRALITY_CHECK_WRT (caret, ^ )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(caret, ^ )

//------------------------------------------------------------------------------
// Commutativity
@@ -152,14 +152,14 @@
#define CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag) check_commutativity_wrt_equal_##op_tag
#define CHECK_COMMUTATIVITY_WRT(op_tag) check_commutativity_wrt_##op_tag

-DEFINE_COMMUTATIVITY_CHECK_WRT (plus, + );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(plus, + );
-DEFINE_COMMUTATIVITY_CHECK_WRT (pipe, | );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(pipe, | );
-DEFINE_COMMUTATIVITY_CHECK_WRT (et, & );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(et, & );
-DEFINE_COMMUTATIVITY_CHECK_WRT (caret, ^ );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ );
+DEFINE_COMMUTATIVITY_CHECK_WRT (plus, + )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(plus, + )
+DEFINE_COMMUTATIVITY_CHECK_WRT (pipe, | )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(pipe, | )
+DEFINE_COMMUTATIVITY_CHECK_WRT (et, & )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(et, & )
+DEFINE_COMMUTATIVITY_CHECK_WRT (caret, ^ )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ )

//------------------------------------------------------------------------------
// Natural inversion
@@ -186,10 +186,10 @@
#define CHECK_PARTIAL_INVERSION_WRT_EQUAL(plus_tag) check_partial_inversion_wrt_equal_##plus_tag
#define CHECK_PARTIAL_INVERSION_WRT(plus_tag) check_partial_inversion_wrt_##plus_tag

-DEFINE_PARTIAL_INVERSION_CHECK_WRT (plus, + );
-DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus, + );
-DEFINE_PARTIAL_INVERSION_CHECK_WRT (pipe, | );
-DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(pipe, | );
+DEFINE_PARTIAL_INVERSION_CHECK_WRT (plus, + )
+DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus, + )
+DEFINE_PARTIAL_INVERSION_CHECK_WRT (pipe, | )
+DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(pipe, | )

//------------------------------------------------------------------------------
// Inverse
@@ -220,10 +220,10 @@
#define CHECK_INVERSE_WRT_EQUAL(plus_tag) check_inverse_wrt_equal_##plus_tag
#define CHECK_INVERSE_WRT(plus_tag) check_inverse_wrt_##plus_tag

-DEFINE_INVERSE_CHECK_WRT (plus, + );
-DEFINE_INVERSE_CHECK_WRT_EQUAL(plus, + );
-DEFINE_INVERSE_CHECK_WRT (pipe, | );
-DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe, | );
+DEFINE_INVERSE_CHECK_WRT (plus, + )
+DEFINE_INVERSE_CHECK_WRT_EQUAL(plus, + )
+DEFINE_INVERSE_CHECK_WRT (pipe, | )
+DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe, | )

//------------------------------------------------------------------------------
// Containedness laws (Valid for sets, NOT for maps)
@@ -360,14 +360,14 @@
     CHECK_NEUTRALITY_WRT(op_tag)(a,identity_element); \
}

-DEFINE_MONOID_CHECK_WRT(plus);
-DEFINE_MONOID_CHECK_WRT_EQUAL(plus);
-DEFINE_MONOID_CHECK_WRT(pipe);
-DEFINE_MONOID_CHECK_WRT_EQUAL(pipe);
-DEFINE_MONOID_CHECK_WRT(et);
-DEFINE_MONOID_CHECK_WRT_EQUAL(et);
-DEFINE_MONOID_CHECK_WRT(caret);
-DEFINE_MONOID_CHECK_WRT_EQUAL(caret);
+DEFINE_MONOID_CHECK_WRT (plus)
+DEFINE_MONOID_CHECK_WRT_EQUAL(plus)
+DEFINE_MONOID_CHECK_WRT (pipe)
+DEFINE_MONOID_CHECK_WRT_EQUAL(pipe)
+DEFINE_MONOID_CHECK_WRT (et)
+DEFINE_MONOID_CHECK_WRT_EQUAL(et)
+DEFINE_MONOID_CHECK_WRT (caret)
+DEFINE_MONOID_CHECK_WRT_EQUAL(caret)

#define CHECK_MONOID_WRT(op_tag) check_monoid_wrt_##op_tag
#define CHECK_MONOID_WRT_EQUAL(op_tag) check_monoid_wrt_equal_##op_tag
@@ -399,14 +399,14 @@
     CHECK_COMMUTATIVITY_WRT(op_tag)(a,c); \
}

-DEFINE_ABELIAN_MONOID_CHECK_WRT(plus);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(plus);
-DEFINE_ABELIAN_MONOID_CHECK_WRT(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_WRT(et);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(et);
-DEFINE_ABELIAN_MONOID_CHECK_WRT(caret);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(caret);
+DEFINE_ABELIAN_MONOID_CHECK_WRT (plus)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(plus)
+DEFINE_ABELIAN_MONOID_CHECK_WRT (pipe)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(pipe)
+DEFINE_ABELIAN_MONOID_CHECK_WRT (et)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(et)
+DEFINE_ABELIAN_MONOID_CHECK_WRT (caret)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(caret)

#define CHECK_ABELIAN_MONOID_WRT(op_tag) check_abelian_monoid_wrt_##op_tag
#define CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag) check_abelian_monoid_wrt_equal_##op_tag
@@ -434,14 +434,14 @@
     CHECK_PARTIAL_INVERSION_WRT(op_tag)(identity_element,a); \
}

-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(caret);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(caret);
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (caret)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(caret)

#define CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag) check_partial_invertive_monoid_wrt_##op_tag
#define CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag) check_partial_invertive_monoid_wrt_equal_##op_tag
@@ -471,10 +471,10 @@
}

-DEFINE_ABELIAN_GROUP_CHECK_WRT(plus);
-DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(plus);
-DEFINE_ABELIAN_GROUP_CHECK_WRT(pipe);
-DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(pipe);
+DEFINE_ABELIAN_GROUP_CHECK_WRT (plus)
+DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(plus)
+DEFINE_ABELIAN_GROUP_CHECK_WRT (pipe)
+DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(pipe)

#define CHECK_ABELIAN_GROUP_WRT(op_tag) check_abelian_group_wrt_##op_tag
#define CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag) check_abelian_group_wrt_equal_##op_tag
@@ -506,14 +506,14 @@
}

-DEFINE_MONOID_CHECK_PERMUTED_WRT(plus);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_MONOID_CHECK_PERMUTED_WRT(pipe);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe);
-DEFINE_MONOID_CHECK_PERMUTED_WRT(et);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et);
-DEFINE_MONOID_CHECK_PERMUTED_WRT(caret);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret);
+DEFINE_MONOID_CHECK_PERMUTED_WRT (plus)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_MONOID_CHECK_PERMUTED_WRT (pipe)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
+DEFINE_MONOID_CHECK_PERMUTED_WRT (et)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
+DEFINE_MONOID_CHECK_PERMUTED_WRT (caret)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)

#define CHECK_MONOID_PERMUTED_WRT(op_tag) check_monoid_permuted_wrt_##op_tag
#define CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_monoid_permuted_wrt_equal_##op_tag
@@ -546,14 +546,14 @@
}

-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(plus);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(et);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(et);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(caret);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret);
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (plus)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (pipe)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (et)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (caret)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)

#define CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag) check_abelian_monoid_permuted_wrt_##op_tag
#define CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_abelian_monoid_permuted_wrt_equal_##op_tag
@@ -586,14 +586,14 @@
}

-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(caret);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret);
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (caret)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)

#define CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag) check_partial_invertive_monoid_permuted_wrt_##op_tag
#define CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_partial_invertive_monoid_permuted_wrt_equal_##op_tag
@@ -626,10 +626,10 @@
}

-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(plus);
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(pipe);
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(pipe);
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT (plus)
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT (pipe)
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(pipe)

#define CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag) check_abelian_group_permuted_wrt_##op_tag
#define CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag) check_abelian_group_permuted_wrt_equal_##op_tag
@@ -661,14 +661,14 @@
     CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}

-DEFINE_MONOID_CHECK_INSTANCE_WRT(plus);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_MONOID_CHECK_INSTANCE_WRT(pipe);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe);
-DEFINE_MONOID_CHECK_INSTANCE_WRT(et);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et);
-DEFINE_MONOID_CHECK_INSTANCE_WRT(caret);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret);
+DEFINE_MONOID_CHECK_INSTANCE_WRT (plus)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_MONOID_CHECK_INSTANCE_WRT (pipe)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
+DEFINE_MONOID_CHECK_INSTANCE_WRT (et)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
+DEFINE_MONOID_CHECK_INSTANCE_WRT (caret)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)

#define CHECK_MONOID_INSTANCE_WRT(op_tag) check_monoid_instance_wrt_##op_tag
#define CHECK_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_monoid_instance_wrt_equal_##op_tag
@@ -701,14 +701,14 @@
     CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}

-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(plus);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(et);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(et);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(caret);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret);
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (plus)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (pipe)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (et)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (caret)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)

#define CHECK_ABELIAN_MONOID_INSTANCE_WRT(op_tag) check_abelian_monoid_instance_wrt_##op_tag
#define CHECK_ABELIAN_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_abelian_monoid_instance_wrt_equal_##op_tag
@@ -740,14 +740,14 @@
     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}

-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(caret);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret);
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (caret)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)

#define CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(op_tag) check_partial_invertive_monoid_instance_wrt_##op_tag
#define CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_partial_invertive_monoid_instance_wrt_equal_##op_tag
@@ -779,15 +779,15 @@
     CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}

-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(plus);
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(pipe);
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(pipe);
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT (plus)
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT (pipe)
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(pipe)

#define CHECK_ABELIAN_GROUP_INSTANCE_WRT(op_tag) check_abelian_group_instance_wrt_##op_tag
#define CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(op_tag) check_abelian_group_instance_wrt_equal_##op_tag

}} // namespace icl boost

-#endif // LIBS_ICL_TEST_TEST_ICL_laws_h_JOFA_080920__
+#endif // BOOST_LIBS_ICL_TEST_ICL_LAWS_HPP_JOFA_090119

Modified: sandbox/icl/libs/icl/test/test_partial_icl_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_partial_icl_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/test_partial_icl_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -51,14 +51,14 @@
(test_itl_partial_enricher_icl_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
{ icl_quantifier_check_abelian_monoid_et_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}

-// x - x =p= 0 | partial enricher
+// x - x =d= 0 | partial enricher
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_partial_enricher_icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types, T, bicremental_types)
{ icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

//------------------------------------------------------------------------------
// Containedness

Modified: sandbox/icl/libs/icl/test/test_partial_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_partial_interval_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/test_partial_interval_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -51,14 +51,14 @@
(test_itl_partial_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}

-// x - x =p= 0 | partial enricher
+// x - x =d= 0 | partial enricher
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_partial_enricher_itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types, T, bicremental_types)
{ itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

//------------------------------------------------------------------------------

Modified: sandbox/icl/libs/icl/test/test_quantifier_icl_map.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_quantifier_icl_map.hpp (original)
+++ sandbox/icl/libs/icl/test/test_quantifier_icl_map.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,27 +1,19 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_quantifier_itl_map_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_quantifier_itl_map_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_QUANTIFIER_ICL_MAP_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_QUANTIFIER_ICL_MAP_HPP_JOFA_090119

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -46,15 +38,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -82,15 +66,7 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -115,15 +91,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -151,15 +119,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -183,18 +143,10 @@
}

//------------------------------------------------------------------------------
-// Abelian partial invertive monoid with protonic equality for inversion
+// Abelian partial invertive monoid with distinct equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -216,8 +168,10 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair1, map_pair2);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair1, map_pair2);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+#endif
}

@@ -225,15 +179,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -257,18 +203,10 @@
}

//------------------------------------------------------------------------------
-// (0 - x) + x =p= 0 |
+// (0 - x) + x =d= 0 |
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -290,9 +228,11 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+#endif
}

-#endif // LIBS_ICL_TEST_TEST_ICL_quantifier_itl_map_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_QUANTIFIER_ICL_MAP_HPP_JOFA_090119

Modified: sandbox/icl/libs/icl/test/test_quantifier_map_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_quantifier_map_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_quantifier_map_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,27 +1,19 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_itv_quantifier_shared_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_itv_quantifier_shared_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_QUANTIFIER_MAP_SHARED_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_QUANTIFIER_MAP_SHARED_HPP_JOFA_090119

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -40,15 +32,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -70,15 +54,7 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -97,15 +73,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -127,15 +95,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -153,18 +113,10 @@
}

//------------------------------------------------------------------------------
-// Abelian partial invertive monoid with protonic equality for inversion
+// Abelian partial invertive monoid with distinct equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -180,8 +132,10 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+#endif
}

@@ -189,15 +143,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -215,18 +161,10 @@
}

//------------------------------------------------------------------------------
-// (0 - x) + x =p= 0 |
+// (0 - x) + x =d= 0 |
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -242,9 +180,11 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);

+#if !defined(_MSC_VER) || (_MSC_VER >= 1400) // 1310==MSVC-7.1 1400 ==MSVC-8.0
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+#endif
}

-#endif // LIBS_ICL_TEST_TEST_ICL_itv_quantifier_shared_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_QUANTIFIER_MAP_SHARED_HPP_JOFA_090119

Modified: sandbox/icl/libs/icl/test/test_set_icl_set.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_set_icl_set.hpp (original)
+++ sandbox/icl/libs/icl/test/test_set_icl_set.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,24 +1,19 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_set_itl_set_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_set_itl_set_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_SET_ICL_SET_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_SET_ICL_SET_HPP_JOFA_090119

+#include "portability.hpp"

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -42,13 +37,7 @@
     CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -76,13 +65,7 @@
// Abelian monoid EANC
//------------------------------------------------------------------------------

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -106,13 +89,7 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -140,13 +117,7 @@
//------------------------------------------------------------------------------
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -170,5 +141,5 @@
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}

-#endif // LIBS_ICL_TEST_TEST_ICL_set_itl_set_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_SET_ICL_SET_HPP_JOFA_090119

Modified: sandbox/icl/libs/icl/test/test_set_interval_set_shared.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_set_interval_set_shared.hpp (original)
+++ sandbox/icl/libs/icl/test/test_set_interval_set_shared.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -1,28 +1,22 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_set_interval_set_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_set_interval_set_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_SET_INTERVAL_SET_SHARED_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_SET_INTERVAL_SET_SHARED_HPP_JOFA_090119

+#include "portability.hpp"

-
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void make_3_interval_sets_and_derivatives_1
- (IntervalSet<T>& set_a,
- IntervalSet<T>& set_b,
- IntervalSet<T>& set_c,
- typename IntervalSet<T>::segment_type& segm_d,
- typename IntervalSet<T>::element_type& elem_e)
+ (ICL_PORT_msvc_7_1_IntervalSet(T)& set_a,
+ ICL_PORT_msvc_7_1_IntervalSet(T)& set_b,
+ ICL_PORT_msvc_7_1_IntervalSet(T)& set_c,
+ typename ICL_PORT_msvc_7_1_IntervalSet(T)::segment_type& segm_d,
+ typename ICL_PORT_msvc_7_1_IntervalSet(T)::element_type& elem_e)
{
     typedef IntervalSet<T> IntervalSetT;
     typedef typename IntervalSetT::segment_type IntervalT;
@@ -42,13 +36,7 @@
//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -66,13 +54,7 @@
     CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -94,13 +76,7 @@
// Abelian monoid EANC
//------------------------------------------------------------------------------

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -118,13 +94,7 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -146,13 +116,7 @@
//------------------------------------------------------------------------------
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -174,13 +138,7 @@
//------------------------------------------------------------------------------
// Containedness
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_containedness_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -205,13 +163,7 @@
//------------------------------------------------------------------------------
// Inner complement
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_inner_complementarity_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -228,13 +180,7 @@
     has_inner_complementarity<IntervalSetT,IntervalSetT>(set_c);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_length_complementarity_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -255,7 +201,5 @@
     has_length_as_distance<IntervalSetT,IntervalSetT>(set_c);
}

-
-
-#endif // LIBS_ICL_TEST_TEST_ICL_set_interval_set_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_SET_INTERVAL_SET_SHARED_HPP_JOFA_090119

Modified: sandbox/icl/libs/icl/test/test_total_icl_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_total_icl_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/test_total_icl_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -59,7 +59,7 @@
(test_itl_total_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, float, total_enricher, INTERVAL_MAP>();}

-// (0-x) + x =p= 0 | total absorber
+// (0-x) + x =d= 0 | total absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
@@ -74,8 +74,8 @@

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

#endif // BOOST_ICL_TEST_TOTAL_ICL_QUANTIFIER_CASES_HPP_JOFA_100819

Modified: sandbox/icl/libs/icl/test/test_total_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_total_interval_quantifier_cases.hpp (original)
+++ sandbox/icl/libs/icl/test/test_total_interval_quantifier_cases.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -59,7 +59,7 @@
(test_itl_total_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, float, total_enricher, INTERVAL_MAP>();}

-// (0-x) + x =p= 0 | total absorber
+// (0-x) + x =d= 0 | total absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
@@ -74,8 +74,8 @@

// absorber enricher
-// partial x - x == 0 x - x =p= 0 partiality of subtraction
-// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
+// partial x - x == 0 x - x =d= 0 partiality of subtraction
+// total (-x)+ x == 0 (-x)+ x =d= 0 totality of subtraction

//------------------------------------------------------------------------------
// Inner complement

Modified: sandbox/icl/libs/icl/test/test_type_lists.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_type_lists.hpp (original)
+++ sandbox/icl/libs/icl/test/test_type_lists.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -17,17 +17,26 @@

#if(_MSC_VER < 1500 && defined(_DEBUG) ) // 1500 = MSVC-9.0
typedef int boost_posix_time_ptime;
+typedef int boost_posix_time_duration;
+typedef int boost_gregorian_date;
+typedef int boost_gregorian_date_duration;
#else
-typedef boost::posix_time::ptime boost_posix_time_ptime;
+typedef boost::posix_time::ptime boost_posix_time_ptime;
+typedef boost::posix_time::time_duration boost_posix_time_duration;
+typedef boost::gregorian::date boost_gregorian_date;
+typedef boost::gregorian::date_duration boost_gregorian_date_duration;
#endif

typedef ::boost::mpl::list<
- unsigned short, unsigned int, unsigned long
+ unsigned short, unsigned int, unsigned long
     ,short, int, long, long long
     ,float, double, long double
     ,boost::rational<int>
     ,boost_posix_time_ptime
-// ,boost::gregorian::date
+ ,boost_posix_time_duration
+ ,boost_gregorian_date
+ ,boost_gregorian_date_duration
+ ,int*
> bicremental_types;

typedef unsigned int bicremental_type_1;
@@ -35,9 +44,10 @@
typedef double bicremental_type_3;
typedef boost::rational<int> bicremental_type_4;
typedef boost_posix_time_ptime bicremental_type_5;
-typedef unsigned short bicremental_type_6;
-typedef short bicremental_type_7;
-typedef float bicremental_type_8;
+typedef short bicremental_type_6;
+typedef float bicremental_type_7;
+typedef int* bicremental_type_8;
+

typedef ::boost::mpl::list<
      short, int, long, long long
@@ -82,7 +92,11 @@
     ,unsigned long, unsigned long long
     ,short, int, long
     ,boost_posix_time_ptime
-// ,boost::gregorian::date
+ ,boost_posix_time_ptime
+ ,boost_posix_time_duration
+ ,boost_gregorian_date
+ ,boost_gregorian_date_duration
+ ,int*
> discrete_types;

typedef int discrete_type_1;
@@ -128,7 +142,10 @@
     ,boost::rational<int>
     ,std::string
     ,boost_posix_time_ptime
-// ,boost::gregorian::date
+ ,boost_posix_time_duration
+ ,boost_gregorian_date
+ ,boost_gregorian_date_duration
+ ,int*
> ordered_types;

typedef int ordered_type_1;

Modified: sandbox/icl/libs/icl/test/test_value_maker.hpp
==============================================================================
--- sandbox/icl/libs/icl/test/test_value_maker.hpp (original)
+++ sandbox/icl/libs/icl/test/test_value_maker.hpp 2010-12-19 14:11:35 EST (Sun, 19 Dec 2010)
@@ -14,16 +14,6 @@
namespace boost{ namespace icl
{

-/*FYI completion like that:
-std::string make(int n)
-{
- std::string value = identity_element<std::string>::value();
- int abs_n = n<0 ? -n : n;
- for(int i=1; i<abs_n; i++)
- value += i%2==1 ? "hello " : "world ";
-}
-*/
-
struct mono
{
     mono(){};
@@ -76,6 +66,44 @@
     }
};

+
+template <class Type>
+struct test_value<Type*>
+{
+
+ static bool map_integers(Type values[], int size)
+ {
+ static const int offset = size/2;
+ for(int idx = 0; idx < size; idx++)
+ values[idx] = test_value<Type>::make(idx - offset);
+
+ return true;
+ }
+
+ static Type* make(int n)
+ {
+ static bool initialized;
+ static const int size = 100;
+ static const int offset = size/2;
+ static Type values[size];
+
+ if(!initialized)
+ initialized = map_integers(values, size);
+
+ Type* value = values + offset;
+ if(n>=0)
+ for(int i=0; i<n; i++)
+ ++value;
+ else
+ for(int i=0; i>n; i--)
+ --value;
+
+ return value;
+ }
+};
+
+
+
template <class Type>
struct test_value
{
@@ -108,7 +136,8 @@
     static interval_type interval_(int lower, int upper, int bounds = 2)
     {
         return interval_type(test_value<domain_type>::make(lower),
- test_value<domain_type>::make(upper), interval_bounds(bounds));
+ test_value<domain_type>::make(upper),
+ interval_bounds(static_cast<bound_type>(bounds)));
     }

     static segment_type val_pair(int lower, int upper, int val, int bounds = 2)
@@ -134,18 +163,18 @@
// Very short value denotation for intervals
// Assumption typename T and IntervalT exists in scope
//I_I : [a,b]
-#define I_I(low,up) icl::interval<T>::closed (make<T>(low), make<T>(up))
+#define I_I(low,up) icl::interval<T>::closed (test_value<T>::make(low), test_value<T>::make(up))
//I_D : [a,b)
-#define I_D(low,up) icl::interval<T>::right_open(make<T>(low), make<T>(up))
+#define I_D(low,up) icl::interval<T>::right_open(test_value<T>::make(low), test_value<T>::make(up))
//C_I : (a,b]
-#define C_I(low,up) icl::interval<T>::left_open (make<T>(low), make<T>(up))
+#define C_I(low,up) icl::interval<T>::left_open (test_value<T>::make(low), test_value<T>::make(up))
//C_D : (a,b)
-#define C_D(low,up) icl::interval<T>::open (make<T>(low), make<T>(up))
+#define C_D(low,up) icl::interval<T>::open (test_value<T>::make(low), test_value<T>::make(up))

-#define MK_I(ItvT,low,up) ItvT(make<T>(low), make<T>(up))
+#define MK_I(ItvT,low,up) ItvT(test_value<T>::make(low), test_value<T>::make(up))

-#define MK_v(key) make<T>(key)
-#define MK_u(key) make<U>(key)
+#define MK_v(key) test_value<T>::make(key)
+#define MK_u(key) test_value<U>::make(key)

// Very short value denotation for interval value pairs
// Assumption typename IntervalMapT existes in scope

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r67354 - sandbox/chrono/boost/static_integer"
Previous message: mr.chr.schmidt_at_[hidden]: "[Boost-commit] svn:boost r67352 - trunk/boost/fusion/sequence/intrinsic"

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