|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r50098 - in sandbox/itl: boost/itl libs/itl/example/boost_party libs/itl/test libs/itl/test/test_interval_map_mixed
From: afojgo_at_[hidden]
Date: 2008-12-03 16:32:07
Author: jofaber
Date: 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
New Revision: 50098
URL: http://svn.boost.org/trac/boost/changeset/50098
Log:
Refactored: Renamed associated types: mapped_type etc. Stable {msvc-9.0}
Text files modified:
sandbox/itl/boost/itl/interval_base_map.hpp | 46 ++++++++++++++-------------------------
sandbox/itl/boost/itl/interval_base_set.hpp | 4 ++
sandbox/itl/boost/itl/interval_map.hpp | 6 ++--
sandbox/itl/boost/itl/interval_maps.hpp | 8 +++---
sandbox/itl/boost/itl/notate.hpp | 4 +++
sandbox/itl/boost/itl/split_interval_map.hpp | 6 ++--
sandbox/itl/boost/itl/split_interval_set.hpp | 14 ------------
sandbox/itl/libs/itl/example/boost_party/boost_party.cpp | 4 ---
sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp | 22 +++++++++---------
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 32 +++++++++++++-------------
10 files changed, 61 insertions(+), 85 deletions(-)
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -49,15 +49,15 @@
{
template<class DomainT, class CodomainT>
-struct base_pair
+struct mapping_pair
{
DomainT key;
CodomainT data;
- base_pair(const DomainT& key_value, const CodomainT& data_value)
+ mapping_pair(const DomainT& key_value, const CodomainT& data_value)
:key(key_value), data(data_value){}
- base_pair(const std::pair<DomainT,CodomainT>& std_pair)
+ mapping_pair(const std::pair<DomainT,CodomainT>& std_pair)
:key(std_pair.first), data(std_pair.second){}
};
@@ -171,9 +171,9 @@
/// Domain type (type of the keys) of the map
typedef CodomainT codomain_type;
/// basic value type
- typedef std::pair<domain_type,codomain_type> base_value_type;
+ typedef std::pair<domain_type,codomain_type> mapping_type;
/// Auxiliary type to help the compiler resolve ambiguities when using std::make_pair
- typedef base_pair<domain_type,codomain_type> base_pair_type;
+ typedef mapping_pair<domain_type,codomain_type> mapping_pair_type;
/// The interval type of the map
typedef Interval<DomainT,Compare> interval_type;
@@ -272,7 +272,7 @@
//--- contains: map view ------------------------------------------------------
/// Does the map contain the element pair <tt>x = (key_element,value)</tt>?
- bool contains(const base_pair_type& x)const
+ bool contains(const mapping_pair_type& x)const
{ return that()->contains_(value_type(interval_type(x.key), x.data)); }
/// Does the map contain all element value pairs represented by the interval-value pair sub?
@@ -322,7 +322,7 @@
/// Addition of a base value pair using a Combinator operation.
/** Addition of a base value pair <tt>x := pair(k,y)</tt> where
- <tt>base_value_type:=pair<DomainT,CodomainT></tt>
+ <tt>mapping_type:=pair<DomainT,CodomainT></tt>
This adds (inserts) a value <tt>y</tt> for a single key <tt>k</tt> into the map.
If <tt>k</tt> already has a value <tt>y0</tt> associated with it, <tt>y0</tt>
@@ -331,15 +331,9 @@
If Combinator implements addition (+=) associated values will contain sums.
If Combinator implements max, associated values will contain maximal values and so on.
*/
- //template<class Combiner>
- //CL? SubType& add(const base_pair_type& x, const Combiner& combine)
- //{
- // access::add(*that(), value_type(interval_type(x.KEY_VALUE), x.CONT_VALUE), combine);
- // return *that();
- //}
/// Addition of a value pair using a Combinator operation.
- /** Addition of a value pair <tt>x := pair(I,y)</tt> where <tt>base_value_type:=pair<DomainT,CodomainT></tt>
+ /** Addition of a value pair <tt>x := pair(I,y)</tt> where <tt>mapping_type:=pair<DomainT,CodomainT></tt>
This adds (inserts) a value <tt>y</tt> an interval <tt>I</tt> into the map.
@@ -365,7 +359,7 @@
public:
/// Addition of a base value pair.
- /** Addition of a base value pair <tt>x := pair(k,y)</tt> where <tt>base_value_type:=pair<DomainT,CodomainT></tt>
+ /** Addition of a base value pair <tt>x := pair(k,y)</tt> where <tt>mapping_type:=pair<DomainT,CodomainT></tt>
This adds (inserts) a value <tt>y</tt> for a single key <tt>k</tt> into the map.
If <tt>k</tt> already has a value <tt>y0</tt> associated with it, <tt>y0</tt>
@@ -374,7 +368,7 @@
Addition and subtraction are reversible as follows:
<tt>m0=m; m.add(x); m.subtract(x);</tt> implies <tt>m==m0 </tt>
*/
- SubType& add(const base_pair_type& x)
+ SubType& add(const mapping_pair_type& x)
{ return add( value_type(interval_type(x.key), x.data) ); }
/// Addition of a base value pair.
@@ -413,12 +407,6 @@
A Combinator for subtract is usually an inverse function of
the corresponding add<Combinator>.
*/
- //template<class Combiner>
- //CL? SubType& subtract(const base_pair_type& x, const Combiner& combine)
- //{
- // that()->subtract_(value_type(interval_type(x.KEY_VALUE), x.CONT_VALUE), combine);
- // return *that();
- //}
/// Subtraction of an interval value pair using a Combinator operation
/** Subtraction of an interval value pair <tt>x=(I,y)</tt>
@@ -437,7 +425,7 @@
public:
/// Subtraction of a base value pair.
- /** Subtraction of a base value pair <tt>x=(k,y)</tt> where <tt>base_value_type:=pair<DomainT,CodomainT></tt>
+ /** Subtraction of a base value pair <tt>x=(k,y)</tt> where <tt>mapping_type:=pair<DomainT,CodomainT></tt>
This subtracts a value <tt>y</tt> for a single key <tt>k</tt> from the map.
If <tt>k</tt> already has a value <tt>y0</tt> associated with it, <tt>y0</tt>
@@ -449,7 +437,7 @@
Insertion and subtraction are reversible as follows:
<tt>m0=m; m.add(x); m.subtract(x);</tt> implies <tt>m==m0 </tt>
*/
- SubType& subtract(const base_pair_type& x)
+ SubType& subtract(const mapping_pair_type& x)
{
return subtract( value_type(interval_type(x.key), x.data) );
}
@@ -486,14 +474,14 @@
//@{
/// Insertion of a base value pair.
- /** Insertion of a base value pair <tt>x=(k,y)</tt> where <tt>base_value_type:=pair<DomainT,CodomainT></tt>
+ /** Insertion of a base value pair <tt>x=(k,y)</tt> where <tt>mapping_type:=pair<DomainT,CodomainT></tt>
This inserts a value <tt>y</tt> for a single key <tt>k</tt> into the map.
Insertion is done only if there is no value \c y0 in the map for key \c k.
This is the insertion semantics known from std::map::insert.
*/
- SubType& insert(const base_pair_type& x)
+ SubType& insert(const mapping_pair_type& x)
{
that()->insert(value_type(interval_type(x.key), x.data));
return *that();
@@ -518,7 +506,7 @@
This does erase a base value pair <tt>x=(k,y)</tt> form the map, if
a value \c y is stored for key \c k.
*/
- SubType& erase(const base_pair_type& x)
+ SubType& erase(const mapping_pair_type& x)
{
that()->erase_(value_type(interval_type(x.key), x.data));
return *that();
@@ -616,7 +604,7 @@
void add_intersection(interval_base_map& section, const domain_type& x)const
{ add_intersection(section, interval_type(x)); }
- void add_intersection(interval_base_map& section, const base_pair_type& x)const
+ void add_intersection(interval_base_map& section, const mapping_pair_type& x)const
{ add_intersection(section, value_type(interval_type(x.key), x.data)); }
/// Intersection with an interval value pair
@@ -1232,7 +1220,7 @@
{
return std::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<std::pair<Interval<DomainT,Compare>, CodomainT> >() //NOTE DESIGN TTP: Why template template parameter Compare is needed
+ Compare<std::pair<Interval<DomainT,Compare>,CodomainT> >()//NOTE DESIGN TTP: Why template template parameter Compare is needed
);
}
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -601,7 +601,9 @@
const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& rhs)
{
return std::lexicographical_compare(
- lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), Compare<Interval<DomainT,Compare> >());
+ lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
+ Compare<Interval<DomainT,Compare> >()//NOTE DESIGN TTP: Why Compare is needs to be ttp
+ );
}
template<class SubType,
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -130,8 +130,8 @@
typedef Interval<DomainT,Compare> interval_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::value_type value_type;
- typedef typename base_type::base_value_type base_value_type;
- typedef typename base_type::base_pair_type base_pair_type;
+ typedef typename base_type::mapping_type mapping_type;
+ typedef typename base_type::mapping_pair_type mapping_pair_type;
typedef typename base_type::ImplMapT ImplMapT;
typedef interval_set<DomainT,Interval,Compare,Alloc> interval_set_type;
@@ -150,7 +150,7 @@
Traits,Interval,Compare,Combine,Alloc>& src)
{ assign(src); }
- explicit interval_map(base_pair_type& base_pair): base_type()
+ explicit interval_map(mapping_pair_type& base_pair): base_type()
{ add(base_pair); }
explicit interval_map(const value_type& value_pair): base_type()
Modified: sandbox/itl/boost/itl/interval_maps.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_maps.hpp (original)
+++ sandbox/itl/boost/itl/interval_maps.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -80,7 +80,7 @@
return object.add(operand);
}
-//--- base_value_type ---------------------------------------------------------
+//--- mapping_type ---------------------------------------------------------
// Addition (+=) of a base value pair.
/* Addition of an value pair <tt>x=(I,y)</tt>
@@ -114,7 +114,7 @@
Traits,Interval,Compare,Combine,Alloc>& object,
const typename
IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>::base_pair_type& operand
+ Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
)
{
return object.add(operand);
@@ -191,7 +191,7 @@
return object.subtract(operand);
}
-//--- base_value_type ---------------------------------------------------------
+//--- mapping_type ---------------------------------------------------------
template
<
class DomainT, class CodomainT,
@@ -211,7 +211,7 @@
Traits,Interval,Compare,Combine,Alloc>& object,
const typename
IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>::base_pair_type& operand
+ Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
)
{
return object.subtract(operand);
Modified: sandbox/itl/boost/itl/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/notate.hpp (original)
+++ sandbox/itl/boost/itl/notate.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -81,6 +81,9 @@
#define ITL_USE_COMBINE_TEMPLATE_TEMPLATE
//------------------------------------------------------------------------------
+// template parameter Compare can not be a template type parameter as long as
+// Compare<Interval<DomainT,Compare> >() is called in std::lexicographical_compare
+// implementing operator< for interval_base_{set,map}. see NOTE DESIGN TTP
#ifdef ITL_USE_COMPARE_TEMPLATE_TEMPLATE
# define ITL_COMPARE template<class>class
# define ITL_COMPARE_DOMAIN(itl_compare, domain_type) itl_compare<domain_type>
@@ -94,6 +97,7 @@
#endif
//------------------------------------------------------------------------------
+// template parameter Combine could be a template type parameter.
#ifdef ITL_USE_COMBINE_TEMPLATE_TEMPLATE
# define ITL_COMBINE template<class>class
# define ITL_COMBINE_CODOMAIN(itl_combine, codomain_type) itl_combine<codomain_type>
Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -151,8 +151,8 @@
typedef Interval<DomainT,Compare> interval_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::value_type value_type;
- typedef typename base_type::base_value_type base_value_type;
- typedef typename base_type::base_pair_type base_pair_type;
+ typedef typename base_type::mapping_type mapping_type;
+ typedef typename base_type::mapping_pair_type mapping_pair_type;
typedef typename base_type::ImplMapT ImplMapT;
typedef interval_set<DomainT,Interval,Compare,Alloc> interval_set_type;
@@ -163,7 +163,7 @@
/// Copy constructor
split_interval_map(const split_interval_map& src): base_type(src) {}
- explicit split_interval_map(base_pair_type& base_pair): base_type()
+ explicit split_interval_map(mapping_pair_type& base_pair): base_type()
{ add(base_pair); }
explicit split_interval_map(const value_type& value_pair): base_type()
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -415,20 +415,6 @@
return Set::lexicographical_equal(lhs, rhs);
}
- /*CL?
- template <typename DomainT, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_ALLOC Alloc>
- inline bool operator < (const split_interval_set<DomainT,Interval,Compare,Alloc>& lhs,
- const split_interval_set<DomainT,Interval,Compare,Alloc>& rhs)
- {
- split_interval_set<DomainT,Interval,Compare,Alloc> lhs_joined = lhs, rhs_joined = rhs;
- lhs_joined.join(); rhs_joined.join(); //JODO EFFI
- return std::lexicographical_compare(
- lhs_joined.begin(), lhs_joined.end(),
- rhs_joined.begin(), rhs_joined.end(),
- Compare<Interval<DomainT,Compare> >());
- }
- */
-
template <class Type>
struct is_set<itl::split_interval_set<Type> >
{ enum{value = true}; };
Modified: sandbox/itl/libs/itl/example/boost_party/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party/boost_party.cpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -68,11 +68,7 @@
typedef interval_map<ptime, GuestSetT> BoostPartyAttendenceHistoryT;
// A party's height shall be defined as the maximum height of all guests ;-)
-#ifdef ITL_USE_COMBINE_TEMPLATE_TEMPLATE
typedef interval_map<ptime, int, neutron_absorber, interval, less, inplace_max > BoostPartyHeightHistoryT;
-#else
-typedef interval_map<ptime, int, neutron_absorber, interval, less<ptime>, inplace_max<int> > BoostPartyHeightHistoryT;
-#endif
void boost_party()
{
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -97,8 +97,8 @@
T v1 = unon<T>::value();
U u1 = unon<U>::value();
- base_pair<T,U> v0_u1(v0,u1);
- base_pair<T,U> v1_u1(v1,u1);
+ mapping_pair<T,U> v0_u1(v0,u1);
+ mapping_pair<T,U> v1_u1(v1,u1);
SplitIntervalMapT split_map;
IntervalMapT join_map;
@@ -234,9 +234,9 @@
std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
std::pair<interval<T>,U> I4_5D_1(I4_5D, u1);
- base_pair<T,U> v1_1(v1, u1);
- base_pair<T,U> v3_1(v3, u1);
- base_pair<T,U> v5_1(v5, u1);
+ mapping_pair<T,U> v1_1(v1, u1);
+ mapping_pair<T,U> v3_1(v3, u1);
+ mapping_pair<T,U> v5_1(v5, u1);
SplitIntervalMapT split_map;
split_map.add(I1_3D_1).add(I2_4D_1);
@@ -789,15 +789,15 @@
split_A.clear();
split_A.add(I0_3D_1).add(I6_9D_1);
split_AB = split_A;
- split_AB *= base_pair<T,U>(v1,u1);
+ split_AB *= mapping_pair<T,U>(v1,u1);
split_ab.clear();
- split_ab.add(base_pair<T,U>(v1,u2));
+ split_ab.add(mapping_pair<T,U>(v1,u2));
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- //(split_AB *= base_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
- split_AB *= base_pair<T,U>(v1,u1);
+ //(split_AB *= mapping_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
+ split_AB *= mapping_pair<T,U>(v1,u1);
split_AB += make_pair(interval<T>::open(v1,v7), u2);
split_ab2.clear();
split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u2);
@@ -889,12 +889,12 @@
split_AB = split_A;
split_AB *= v1;
split_ab.clear();
- split_ab.add(base_pair<T,U>(v1,u1));
+ split_ab.add(mapping_pair<T,U>(v1,u1));
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- //(split_AB *= base_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
+ //(split_AB *= mapping_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
split_AB *= interval<T>(v1);
split_AB += make_pair(interval<T>::open(v1,v7), u1);
split_ab2.clear();
Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2008-12-03 16:32:06 EST (Wed, 03 Dec 2008)
@@ -73,8 +73,8 @@
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
//subtracting elements form emptieness
- typename IntervalMapT::base_pair_type v0_u1 = make_pair(v0,u1);
- typename IntervalMapT::base_pair_type v1_u1 = make_pair(v1,u1);
+ typename IntervalMapT::mapping_pair_type v0_u1 = make_pair(v0,u1);
+ typename IntervalMapT::mapping_pair_type v1_u1 = make_pair(v1,u1);
//mt_map.subtract(make_pair(v0,u1)).subtract(make_pair(v1,u1));
mt_map.subtract(v0_u1).subtract(v1_u1);
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
@@ -173,7 +173,7 @@
T v4 = make<T>(4);
U u2 = make<U>(2);
interval<T> I4_4I(v4);
- typename IntervalMapT::base_pair_type v4_u2(v4,u2);
+ typename IntervalMapT::mapping_pair_type v4_u2(v4,u2);
typename IntervalMapT::value_type I4_4I_u2(I4_4I,u2);
IntervalMapT _I4_4I_u2;
@@ -240,8 +240,8 @@
interval<T> I5_6I(v5,v6);
interval<T> I5_9I(v5,v9);
interval<T> I0_9I = interval<T>::closed(v0, v9);
- typename IntervalMapT::base_pair_type v0_u1 = make_pair(v0, u1);
- typename IntervalMapT::base_pair_type v9_u1 = make_pair(v9, u1);
+ typename IntervalMapT::mapping_pair_type v0_u1 = make_pair(v0, u1);
+ typename IntervalMapT::mapping_pair_type v9_u1 = make_pair(v9, u1);
typename IntervalMapT::value_type I5_6I_u1 = make_pair(I5_6I, u1);
typename IntervalMapT::value_type I5_9I_u1 = make_pair(I5_9I, u1);
typename IntervalMapT::value_type I0_9I_u1 = make_pair(interval<T>::closed(v0, v9), u1);
@@ -291,9 +291,9 @@
T v3 = make<T>(3);
T v5 = make<T>(5);
U u1 = make<U>(1);
- typename IntervalMapT::base_pair_type v1_u1(v1,u1);
- typename IntervalMapT::base_pair_type v3_u1(v3,u1);
- typename IntervalMapT::base_pair_type v5_u1(v5,u1);
+ typename IntervalMapT::mapping_pair_type v1_u1(v1,u1);
+ typename IntervalMapT::mapping_pair_type v3_u1(v3,u1);
+ typename IntervalMapT::mapping_pair_type v5_u1(v5,u1);
size_T s3 = make<size_T>(3);
@@ -323,9 +323,9 @@
T v3 = make<T>(3);
T v5 = make<T>(5);
U u1 = make<U>(1);
- typename IntervalMapT::base_pair_type v1_u1(v1,u1);
- typename IntervalMapT::base_pair_type v3_u1(v3,u1);
- typename IntervalMapT::base_pair_type v5_u1(v5,u1);
+ typename IntervalMapT::mapping_pair_type v1_u1(v1,u1);
+ typename IntervalMapT::mapping_pair_type v3_u1(v3,u1);
+ typename IntervalMapT::mapping_pair_type v5_u1(v5,u1);
size_T s3 = make<size_T>(3);
diff_T d0 = make<diff_T>(0);
@@ -343,12 +343,12 @@
IntervalMapT is_123_5;
is_123_5 = is_1_3_5;
- //OPROM: open problem: Ambiguity resolving value_type and base_value_type for overloaded o= operators.
+ //OPROM: open problem: Ambiguity resolving value_type and mapping_type for overloaded o= operators.
//is_123_5 += make_pair(interval<T>::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
//is_123_5 += make_pair<interval<T>, U>(interval<T>::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
//USASO: unsatisfctory solution 1: explicit IntervalMapT::value_type instead of make_pair
is_123_5 += typename IntervalMapT::value_type(interval<T>::open(v1,v3),u1);
- //USASO: unsatisfctory solution 2: not implementing base_value_type version of o=
+ //USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
BOOST_CHECK_EQUAL( is_123_5.cardinality(), std::numeric_limits<size_T>::infinity() );
BOOST_CHECK_EQUAL( is_123_5.size(), std::numeric_limits<size_T>::infinity() );
@@ -429,9 +429,9 @@
T v11 = make<T>(11);
U u1 = make<U>(1);
- typename IntervalMapT::base_pair_type v3_u1(v3,u1);
- typename IntervalMapT::base_pair_type v9_u1(v9,u1);
- typename IntervalMapT::base_pair_type v11_u1(v11,u1);
+ typename IntervalMapT::mapping_pair_type v3_u1(v3,u1);
+ typename IntervalMapT::mapping_pair_type v9_u1(v9,u1);
+ typename IntervalMapT::mapping_pair_type v11_u1(v11,u1);
typename IntervalMapT::value_type I3_7I_u1(interval<T>(v3,v7),u1);
IntervalMapT im(v3_u1);
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