|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r64456 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/itl_xt boost/itl_xt/detail boost/validate/driver boost/validate/itl boost/validate/laws boost/validate/validater libs/itl/example/boost_party_ libs/itl/example/interval_ libs/itl/example/man_power_ libs/itl/test libs/itl/test/test_casual_ libs/validate/example/boostcon_law_validater_ libs/validate/example/labat_map_copy_conformity_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2010-07-29 17:18:25
Author: jofaber
Date: 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
New Revision: 64456
URL: http://svn.boost.org/trac/boost/changeset/64456
Log:
Updated the test suite for the new types discrete_interval and continuous_interval.
Added:
sandbox/itl/boost/itl/type_traits/is_discrete.hpp (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/continuous_interval.hpp | 5
sandbox/itl/boost/itl/detail/design_config.hpp | 48 +++
sandbox/itl/boost/itl/detail/element_iterator.hpp | 12
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 12
sandbox/itl/boost/itl/detail/map_algo.hpp | 6
sandbox/itl/boost/itl/detail/set_algo.hpp | 6
sandbox/itl/boost/itl/discrete_interval.hpp | 18
sandbox/itl/boost/itl/functions.hpp | 58 +++
sandbox/itl/boost/itl/interval.hpp | 2
sandbox/itl/boost/itl/interval_base_map.hpp | 19
sandbox/itl/boost/itl/interval_base_set.hpp | 6
sandbox/itl/boost/itl/interval_functions.hpp | 33 +-
sandbox/itl/boost/itl/interval_set.hpp | 6
sandbox/itl/boost/itl/map.hpp | 26 ++
sandbox/itl/boost/itl/rightopen_interval.hpp | 6
sandbox/itl/boost/itl/set.hpp | 25 +
sandbox/itl/boost/itl/type_traits/interval_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp | 4
sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 6
sandbox/itl/boost/itl_xt/interval_bitset.hpp | 18 +
sandbox/itl/boost/itl_xt/mapgentor.hpp | 2
sandbox/itl/boost/itl_xt/setgentor.hpp | 2
sandbox/itl/boost/validate/driver/itl_driver.hpp | 8
sandbox/itl/boost/validate/itl/functors.hpp | 12
sandbox/itl/boost/validate/laws/law_violations.hpp | 4
sandbox/itl/boost/validate/validater/law_validater.hpp | 4
sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp | 2
sandbox/itl/libs/itl/example/interval_/interval.cpp | 14
sandbox/itl/libs/itl/example/man_power_/man_power.cpp | 4
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 13
sandbox/itl/libs/itl/test/test_functions.hpp | 3
sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 516 +++++++++++++++++++++------------------
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 152 ++++++----
sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp | 154 ++++++++---
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 104 +++++--
sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp | 5
sandbox/itl/libs/itl/test/test_set_itl_set.hpp | 5
sandbox/itl/libs/itl/test/test_value_maker.hpp | 13
sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp | 2
sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj | 4
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 18
41 files changed, 847 insertions(+), 512 deletions(-)
Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -68,6 +68,11 @@
domain_type upper()const { return _upb; }
interval_bounds bounds()const{ return _bounds; }
+ static continuous_interval open (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::open()); }
+ static continuous_interval rightopen(const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::right_open());}
+ static continuous_interval leftopen (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::left_open()); }
+ static continuous_interval closed (const DomainT& lo, const DomainT& up){ return continuous_interval(lo, up, interval_bounds::closed()); }
+
private:
domain_type _lwb;
domain_type _upb;
Modified: sandbox/itl/boost/itl/detail/design_config.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/design_config.hpp (original)
+++ sandbox/itl/boost/itl/detail/design_config.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -23,16 +23,47 @@
// will be used as default for all interval containers.
// ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS should be defined in the application
// before other includes from the ITL
-//#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
+//#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS //JODO comment this out for the final release
// If ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS is NOT defined, ITL uses intervals
// with dynamic borders as default.
+#ifdef ITL_USE_DYNAMIC_INTERVAL_BORDERS_DEFAULTS //JODO remove this for the final release
+# undef ITL_USE_STATIC_INTERVAL_BORDERS_DEFAULTS
+#endif
+
+//#define ITL_CONCEPT_ORIENTED
+//#define ITL_PURE_CONCEPTUAL
+
+#ifndef ITL_CONCEPT_ORIENTED
+#define ITL_OBJECT_ORIENTED
+#endif
+
+#ifdef ITL_CONCEPT_ORIENTED
+# define ITL_FUN_CALL(func, arg) itl::func(arg)
+# define ITL_FUN_REN(func_obj, func_conc, arg) itl::func_conc(arg)
+#else //ITL_OBJECT_ORIENTED
+# define ITL_FUN_CALL(func,arg) arg.func()
+# define ITL_FUN_REN(func_obj, func_conc, arg) arg.func_obj()
+#endif
+
+#ifdef ITL_OBJECT_ORIENTED
+# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS public
+# define ITL_END_COMMON_MEMBER_FUNCTIONS public
+#else //ITL_CONCEPT_ORIENTED
+# ifdef ITL_PURE_CONCEPTUAL
+# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS private
+# define ITL_END_COMMON_MEMBER_FUNCTIONS public
+# else
+# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS public
+# define ITL_END_COMMON_MEMBER_FUNCTIONS public
+# endif
+#endif
//------------------------------------------------------------------------------
// Auxiliary macros for denoting template signatures.
// Purpose:
// (1) Shorten the lenthy and redundant template signatures.
-// (2) Name anonymous template types according to theirs meaning ...
+// (2) Name anonymous template types according to their meaning ...
// (3) Making easier to refactor by redefinitin of the macros
// (4) Being able to check template template parameter variants against
// template type parameter variants.
@@ -114,7 +145,7 @@
//CL #define ITL_INTERVAL_DEFAULT itl::continuous_interval
#ifdef ITL_NEW_INTERVAL_IMPL
-# define ITL_INTERVAL_DEFAULT itl::interval_type_of
+# define ITL_INTERVAL_DEFAULT boost::itl::interval_type_of
#else
# define ITL_INTERVAL_DEFAULT boost::itl::interval
#endif
@@ -122,10 +153,13 @@
//------------------------------------------------------------------------------
//JODO find proper solution here
#ifdef ITL_NEW_INTERVAL_IMPL
-//# define ITL_discrt_INTERVAL_DEF itl::discrete_interval
-//# define ITL_contin_INTERVAL_DEF itl::continuous_interval
-# define ITL_discrt_INTERVAL_DEF itl::rightopen_interval
-# define ITL_contin_INTERVAL_DEF itl::rightopen_interval
+# ifdef ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
+# define ITL_discrt_INTERVAL_DEF itl::rightopen_interval
+# define ITL_contin_INTERVAL_DEF itl::rightopen_interval
+# else
+# define ITL_discrt_INTERVAL_DEF itl::discrete_interval
+# define ITL_contin_INTERVAL_DEF itl::continuous_interval
+# endif
#else
# define ITL_discrt_INTERVAL_DEF itl::interval
# define ITL_contin_INTERVAL_DEF itl::interval
Modified: sandbox/itl/boost/itl/detail/element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_iterator.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_iterator.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -199,13 +199,13 @@
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->last(); }
- static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(*leaper);}
+ static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(*leaper);}
static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
const domain_difference_type& sneaker)
{
- inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(*leaper) - sneaker
- : itl::first(*leaper) + sneaker;
+ inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(*leaper) - sneaker
+ : itl::first(*leaper) + sneaker;
return inter_pos;
}
};
@@ -223,13 +223,13 @@
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); }
- static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(leaper->first);}
+ static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(leaper->first);}
static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
const domain_difference_type& sneaker)
{
- inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(leaper->first) - sneaker
- : itl::first(leaper->first) + sneaker;
+ inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(leaper->first) - sneaker
+ : itl::first(leaper->first) + sneaker;
return transit_type(inter_pos, leaper->second);
}
};
Modified: sandbox/itl/boost/itl/detail/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_set_algo.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -29,7 +29,8 @@
size_type interval_size;
ITL_const_FORALL(typename IntervalContainerT, it, object)
{
- interval_size = continuous_interval_<interval_type>::cardinality(IntervalContainerT::key_value(it));
+ //CL interval_size = continuous_interval_<interval_type>::cardinality(IntervalContainerT::key_value(it));
+ interval_size = itl::cardinality(IntervalContainerT::key_value(it));
if(interval_size == infinity<size_type>::value())
return interval_size;
else
@@ -172,13 +173,15 @@
{
if(IntervalContainerT::codomain_value(next_) != co_value)
return false;
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
return false;
}
}
else
while(next_ != container.end() && it_ != past)
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
return false;
return true;
@@ -201,7 +204,8 @@
++next_;
while(next_ != container.end() && it_ != past)
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
return false;
return true;
Modified: sandbox/itl/boost/itl/detail/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/map_algo.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -28,8 +28,8 @@
bool contained_in(const MapType& sub, const MapType& super)
{
if(&super == &sub) return true;
- if(sub.empty()) return true;
- if(super.empty()) return false;
+ if(ITL_FUN_REN(empty, is_empty, sub)) return true;
+ if(ITL_FUN_REN(empty, is_empty, super)) return false;
if(super.size() < sub.size() ) return false;
if(*sub.begin() < *super.begin()) return false;
if(*super.rbegin() < *sub.rbegin() ) return false;
@@ -120,7 +120,7 @@
{
if(mpl::and_<is_total<MapType>, absorbs_neutrons<MapType> >::value)
{
- result.clear();
+ ITL_FUN_CALL(clear, result);
return;
}
Modified: sandbox/itl/boost/itl/detail/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/set_algo.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -36,7 +36,7 @@
lwb = x1.end();
upb = x1.end();
- if(x1.empty() || x2.empty())
+ if(ITL_FUN_REN(empty, is_empty, x1) || ITL_FUN_REN(empty, is_empty, x2))
return false;
IteratorT x1_fst_ = x1.begin();
@@ -115,8 +115,8 @@
bool contained_in(const SetType& sub, const SetType& super)
{
if(&super == &sub) return true;
- if(sub.empty()) return true;
- if(super.empty()) return false;
+ if(ITL_FUN_REN(empty, is_empty, sub)) return true;
+ if(ITL_FUN_REN(empty, is_empty, super)) return false;
if(*sub.begin() < *super.begin()) return false;
if(*super.rbegin() < *sub.rbegin() ) return false;
Modified: sandbox/itl/boost/itl/discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/discrete_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -70,20 +70,22 @@
domain_type upper()const { return _upb; }
interval_bounds bounds()const{ return _bounds; }
+ /*CL
domain_type first()const
- {
- return _bounds.left().bits()==2 ? _lwb : succ(_lwb);
- }
+ {
+ return _bounds.left().bits()==2 ? _lwb : succ(_lwb);
+ }
DomainT last()const
{
- return _bounds.right().bits()==1 ? _upb : pred(_upb);
+ return _bounds.right().bits()==1 ? _upb : pred(_upb);
}
+ */
- static discrete_interval open (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::open()); }
- static discrete_interval rightopen(const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::right_open());}
- static discrete_interval leftopen (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::left_open()); }
- static discrete_interval closed (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::closed()); }
+ static discrete_interval open (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::open()); }
+ static discrete_interval rightopen(const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::right_open());}
+ static discrete_interval leftopen (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::left_open()); }
+ static discrete_interval closed (const DomainT& lo, const DomainT& up){ return discrete_interval(lo, up, interval_bounds::closed()); }
private:
domain_type _lwb;
Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 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
@@ -17,6 +17,49 @@
namespace boost{namespace itl
{
+//==========================================================================
+//= Containedness
+//==========================================================================
+
+/** All content of the container is dropped.
+ Complexity: linear. */
+template<class ObjectT>
+typename boost::enable_if<is_interval_container<ObjectT>, void>::type
+clear(ObjectT& object) //JODO test
+{
+#ifdef ITL_CONCEPT_ORIENTED //JODO find final decision
+ object.erase(object.begin(), object.end());
+#else //ITL_OBJECT_ORIENTED
+ object.clear();
+#endif
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template<class ObjectT>
+typename boost::enable_if<is_interval_container<ObjectT>, bool>::type
+is_empty(const ObjectT& object)
+{
+#ifdef ITL_CONCEPT_ORIENTED //JODO find final decision
+ return object.begin() == object.end();
+#else //ITL_OBJECT_ORIENTED
+ return object.empty();
+#endif
+}
+
+/** Does \c super contain \c sub?
+ Complexity: linear. */
+//template<class ObjectT>
+//typename boost::enable_if<is_interval_container<ObjectT>, bool>::type
+//contains(const ObjectT& super, const ObjectT& sub)
+//{
+//#ifdef ITL_CONCEPT_ORIENTED
+// return true; //JODO
+//#else //ITL_OBJECT_ORIENTED
+// return super.contains(sub);
+//#endif
+//}
+
//==============================================================================
//= Equivalences and Orderings
//==============================================================================
@@ -320,7 +363,7 @@
ObjectT>::type&
erase(ObjectT& object, const OperandT& operand)
{
- if(operand.empty())
+ if(ITL_FUN_REN(empty, is_empty, operand))
return object;
typename OperandT::const_iterator common_lwb;
@@ -402,7 +445,7 @@
while(it_ != right_common_upper_)
{
left.add_intersection(intersection, *it_++);
- if(!intersection.empty())
+ if(!ITL_FUN_REN(empty, is_empty, intersection))
return true;
}
@@ -421,7 +464,7 @@
{
LeftT intersection;
- if(left.empty() || right.empty())
+ if(ITL_FUN_REN(empty, is_empty, left) || ITL_FUN_REN(empty, is_empty, right))
return false;
typename RightT::const_iterator right_common_lower_;
@@ -434,7 +477,7 @@
while(it_ != right_common_upper_)
{
left.add_intersection(intersection, RightT::key_value(it_++));
- if(!intersection.empty())
+ if(!ITL_FUN_REN(empty, is_empty, intersection))
return true;
}
@@ -528,9 +571,8 @@
hull(const ObjectT& object)
{
return
- object.empty() ? neutron<typename ObjectT::interval_type>::value()
- : (ObjectT::key_value(object.begin()))
- .span(ObjectT::key_value(object.rbegin()));
+ ITL_FUN_REN(empty, is_empty, object) ? neutron<typename ObjectT::interval_type>::value()
+ : hull((ObjectT::key_value(object.begin())), ObjectT::key_value(object.rbegin()));
}
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -502,7 +502,7 @@
static typename IntervalT::size_type cardinality(const IntervalT& x)
{
typedef typename IntervalT::size_type SizeT;
- if(x.empty())
+ if(itl::is_empty(x))
return itl::neutron<SizeT>::value();
else if(x.is(itl::closed_bounded) && IntervalT::domain_equal(x.lower(), x.upper()))
return itl::unon<SizeT>::value();
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 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -219,13 +219,14 @@
//==========================================================================
//= Containedness
//==========================================================================
-
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
/** clear the map */
void clear() { _map.clear(); }
/** is the map empty? */
bool empty()const { return _map.empty(); }
+ITL_END_COMMON_MEMBER_FUNCTIONS:
//--- contains: set view ---------------------------------------------------
/** Does the map contain the domain element \c key? */
bool contains(const domain_type& key)const
@@ -246,7 +247,7 @@
const_iterator last_overlap = prior(exterior.second);
return
- hull(exterior.first->first, last_overlap->first).contains(sub_interval)
+ itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
&& Interval_Set::is_dense(*this, exterior.first, last_overlap);
}
@@ -492,7 +493,7 @@
{
typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> operand_type;
- if(operand.empty())
+ if(ITL_FUN_REN(empty, is_empty, operand))
return *that();
typename operand_type::const_iterator common_lwb;
@@ -556,7 +557,7 @@
)const
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> sectant_type;
- if(sectant.empty())
+ if(ITL_FUN_REN(empty, is_empty, sectant))
return;
typename sectant_type::const_iterator common_lwb;
@@ -621,7 +622,7 @@
type intersection;
add_intersection(intersection, interval_value_pair);
- return !itl::is_empty(intersection);
+ return !ITL_FUN_REN(empty, is_empty, intersection);
}
@@ -877,8 +878,8 @@
return false;
return
- hull(exterior.first->first, last_overlap->first).contains(sub_interval)
- && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
+ itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
}
@@ -920,7 +921,7 @@
{
difference_type length = neutron<difference_type>::value();
const_FOR_IMPLMAP(it_)
- length += it_->first.length();
+ length += itl::length(it_->first);
return length;
}
@@ -1099,7 +1100,7 @@
while(it_ != end_ )
{
const codomain_type& co_value = it_->second;
- covered = (*it_++).first;
+ covered = (*it_++).first;
//[a ... : span
// [b ... : covered
//[a b) : left_over
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 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -164,11 +164,13 @@
//= Containedness
//==========================================================================
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
/** sets the container empty */
void clear() { _set.clear(); }
/** is the container empty? */
bool empty()const { return _set.empty(); }
+ITL_END_COMMON_MEMBER_FUNCTIONS:
/** Does the container contain the element \c key ? */
bool contains(const element_type& key)const
{ return that()->contains(interval_type(key)); }
@@ -186,7 +188,7 @@
const_iterator last_overlap = prior(exterior.second);
return
- hull(*(exterior.first), *last_overlap).contains(sub_interval)
+ itl::contains(hull(*(exterior.first), *last_overlap), sub_interval)
&& Interval_Set::is_joinable(*this, exterior.first, last_overlap);
}
@@ -521,7 +523,7 @@
{
difference_type length = neutron<difference_type>::value();
const_FOR_IMPL(it_)
- length += (*it_).length();
+ length += itl::length(*it_);
return length;
}
Modified: sandbox/itl/boost/itl/interval_functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_functions.hpp (original)
+++ sandbox/itl/boost/itl/interval_functions.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -115,7 +115,7 @@
typename boost::enable_if<is_discrete_interval<IntervalT>, IntervalT>::type
construct(const typename IntervalT::domain_type& low,
const typename IntervalT::domain_type& up,
- interval_bounds bounds = interval_bounds::right_open() )
+ interval_bounds bounds = interval_bounds::right_open() )
{
return construct_interval<IntervalT>::apply(low, up, bounds);
}
@@ -158,7 +158,7 @@
typename IntervalT::domain_type>::type
first(const IntervalT& object)
{
- return object.lower();
+ return object.lower();
}
template<class IntervalT>
@@ -167,8 +167,8 @@
typename IntervalT::domain_type>::type
first(const IntervalT& object)
{
- return is_left_closed(object.bounds()) ?
- object.lower() : succ(object.lower());
+ return is_left_closed(object.bounds()) ?
+ object.lower() : succ(object.lower());
}
//- last -----------------------------------------------------------------------
@@ -179,7 +179,7 @@
typename IntervalT::domain_type>::type
last(const IntervalT& object)
{
- return pred(object.upper());
+ return pred(object.upper());
}
template<class IntervalT>
@@ -188,7 +188,7 @@
typename IntervalT::domain_type>::type
last(const IntervalT& object)
{
- return is_right_closed(object.bounds()) ? object.upper() : pred(object.upper());
+ return is_right_closed(object.bounds()) ? object.upper() : pred(object.upper());
}
@@ -253,7 +253,14 @@
typename boost::enable_if<is_discrete_interval<IntervalT>, bool>::type
is_empty(const IntervalT& object)
{
- return IntervalT::domain_less(last(object), first(object));
+ //CL return IntervalT::domain_less(last(object), first(object));
+
+ if(object.bounds() == interval_bounds::closed())
+ return IntervalT::domain_less(object.upper(), object.lower());
+ else if(object.bounds() == interval_bounds::open())
+ return IntervalT::domain_less_equal(object.upper(), succ(object.lower()));
+ else
+ return IntervalT::domain_less_equal(object.upper(), object.lower());
}
template<class IntervalT>
@@ -584,7 +591,7 @@
typename IntervalT::size_type>::type
cardinality(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
+ return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
}
@@ -605,7 +612,7 @@
typename IntervalT::size_type>::type
cardinality(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
+ return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
}
@@ -625,7 +632,7 @@
typename IntervalT::difference_type>::type
length(const IntervalT& object)
{
- return object.upper() - object.lower();
+ return object.upper() - object.lower();
}
template<class IntervalT>
@@ -633,7 +640,7 @@
typename IntervalT::difference_type>::type
length(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::difference_type>::value())
+ return (last(object) + itl::unon<IntervalT::difference_type>::value())
- first(object);
}
@@ -642,7 +649,7 @@
typename IntervalT::difference_type>::type
length(const IntervalT& object)
{
- return object.upper() - object.lower();
+ return object.upper() - object.lower();
}
template<class IntervalT>
@@ -650,7 +657,7 @@
typename IntervalT::difference_type>::type
length(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::difference_type>::value())
+ return (last(object) + itl::unon<IntervalT::difference_type>::value())
- first(object);
}
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -212,8 +212,8 @@
::join_on_left(iterator& left_, const iterator& right_)
{
// both left and right are in the set and they are neighbours
- BOOST_ASSERT((*left_).exclusive_less(*right_));
- BOOST_ASSERT((*left_).touches(*right_));
+ BOOST_ASSERT(exclusive_less(*left_, *right_));
+ BOOST_ASSERT(touches(*left_, *right_));
interval_type right_itv = (*right_);
this->_set.erase(right_);
@@ -254,7 +254,7 @@
typename interval_set<DomainT,Compare,Interval,Alloc>::iterator
interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
{
- if(boost::itl::is_empty(addend))
+ if(boost::itl::is_empty(addend))
return prior_;
iterator insertion = this->_set.insert(prior_, addend);
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -173,9 +173,11 @@
void swap(map& src) { base_type::swap(src); }
//==========================================================================
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
using base_type::empty;
using base_type::clear;
+ITL_END_COMMON_MEMBER_FUNCTIONS:
using base_type::begin;
using base_type::end;
using base_type::rbegin;
@@ -715,6 +717,30 @@
// non member functions
//-----------------------------------------------------------------------------
+
+//==========================================================================
+//= Containedness
+//==========================================================================
+//JODO general container concept
+/** All content of the container is dropped.
+ Complexity: linear. */
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+void clear(itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object) //JODO test
+{
+ //object.clear();
+ object.erase(object.begin(), object.end());
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+bool is_empty(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
+{
+ //return object.empty();
+ return object.begin() == object.end();
+}
+
+
//==============================================================================
//= Equivalences and Orderings
//==============================================================================
Modified: sandbox/itl/boost/itl/rightopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/rightopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/rightopen_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -63,7 +63,7 @@
domain_type lower()const{ return _lwb; }
domain_type upper()const{ return _upb; }
- /*CL
+ /*CL
domain_type first()const{ return _lwb; }
DomainT last()const
@@ -71,7 +71,7 @@
BOOST_STATIC_ASSERT((!itl::is_continuous<DomainT>::value));
return pred(_upb);
}
- */
+ */
private:
domain_type _lwb;
@@ -84,7 +84,7 @@
(std::basic_ostream<CharType, CharTraits> &stream,
rightopen_interval<DomainT,Compare> const& object)
{
- if(boost::itl::is_empty(object))
+ if(boost::itl::is_empty(object))
return stream << "[)";
else
return stream << "[" << object.lower() << "," << object.upper()<< ")";
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -121,9 +121,11 @@
set& assign_if(const set& src, const Predicate&);
//==========================================================================
+ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
using base_type::empty;
using base_type::clear;
+ITL_END_COMMON_MEMBER_FUNCTIONS:
using base_type::begin;
using base_type::end;
using base_type::rbegin;
@@ -341,6 +343,29 @@
//-----------------------------------------------------------------------------
// non member functions
//-----------------------------------------------------------------------------
+
+//==========================================================================
+//= Containedness
+//==========================================================================
+//JODO general container concept
+/** All content of the container is dropped.
+ Complexity: linear. */
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+void clear(itl::set<DomainT,Compare,Alloc>& object) //JODO test
+{
+ //object.clear();
+ object.erase(object.begin(), object.end());
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+bool is_empty(const itl::set<DomainT,Compare,Alloc>& object)
+{
+ //return object.empty();
+ return object.begin() == object.end();
+}
+
//==============================================================================
//= Equivalences and Orderings
//==============================================================================
Modified: sandbox/itl/boost/itl/type_traits/interval_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/interval_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/interval_type_of.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -23,7 +23,7 @@
#ifdef ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
typedef rightopen_interval<DomainT,Compare> type;
#else
- typedef
+ typedef
typename mpl::if_< is_continuous<DomainT> //JODO add Traits to choose between static and dynamic intervals
, continuous_interval<DomainT,Compare>
, discrete_interval<DomainT,Compare> >::type type;
Modified: sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -33,7 +33,7 @@
value = (type_traits::ice_and
<
is_asymmetric_interval<Type>::value
- , is_continuous<typename Type::domain_type>::value
+ , is_continuous<typename Type::domain_type>::value
>::value)
);
};
@@ -45,7 +45,7 @@
value = (type_traits::ice_and
<
is_asymmetric_interval<Type>::value
- , type_traits::ice_not<is_continuous<typename Type::domain_type>::value>::value
+ , type_traits::ice_not<is_continuous<typename Type::domain_type>::value>::value
>::value)
);
};
Added: sandbox/itl/boost/itl/type_traits/is_discrete.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/is_discrete.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -0,0 +1,29 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: 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 BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_080910
+#define BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_080910
+
+#include <string>
+#include <boost/type_traits/is_integral.hpp>
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct is_discrete;
+
+ template<class Type> struct is_discrete
+ {
+ typedef is_discrete<Type> type;
+ BOOST_STATIC_CONSTANT(bool, value = is_integral<Type>::value);
+ };
+
+
+}} // namespace boost itl
+
+#endif
+
+
Modified: sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp (original)
+++ sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -124,7 +124,7 @@
next_bit();
if(_on_bit == past)
{ // The current bitset passed the end
- if(_reptator < pred(itl::length(_saltator->first)))
+ if(_reptator < pred(itl::length(_saltator->first)))
{
++_reptator;
_on_bit = ante;
@@ -156,7 +156,7 @@
--_saltator;
// NOW: decrement insecure, because _saltator can (finally) be
// begin here. increment and dereference are secure.
- _reptator = itl::length(_saltator->first);
+ _reptator = itl::length(_saltator->first);
--_reptator;
_on_bit = past;
}
@@ -204,7 +204,7 @@
if(_on_bit == beyond)
{
--_saltator;
- _reptator = itl::length(_saltator->first);
+ _reptator = itl::length(_saltator->first);
--_reptator;
_on_bit = Proceed::last_bit(_saltator->second.word());
}
Modified: sandbox/itl/boost/itl_xt/interval_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/interval_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/interval_bitset.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -148,8 +148,8 @@
interval_bitset& intersect(const element_type& rhs) {return segment_apply(&interval_bitset::intersect_,interval_type(rhs));}
interval_bitset& flip (const element_type& rhs) {return segment_apply(&interval_bitset::flip_, interval_type(rhs));}
- void clear(){ _map.clear(); }
- bool empty()const{ return _map.clear(); }
+ void clear(){ ITL_FUN_CALL(clear, _map); }
+ bool empty()const{ return ITL_FUN_REN(empty, is_empty, _map); }
size_type cardinality()const;
size_type size()const { return cardinality(); }
size_type interval_count()const { return _map.interval_count(); }
@@ -380,7 +380,7 @@
{
size_type cardinality = 0;
ITL_const_FORALL(typename interval_bitmap_type, it_, _map)
- cardinality += (it_->second.cardinality() * itl::cardinality(it_->first));
+ cardinality += (it_->second.cardinality() * itl::cardinality(it_->first));
return cardinality;
}
@@ -415,6 +415,18 @@
const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& right)
{ return left == right; }
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+void clear(interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{
+ object.clear();
+}
+
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
+bool is_empty(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& object)
+{
+ return object.empty();
+}
+
template<class CharType, class CharTraits,
class DomainT, class BitSetT,
Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -60,7 +60,7 @@
void MapGentorT<MapTV>::some(MapTV& x)
{
NumberGentorT<int> intGentor;
- x.clear();
+ ITL_FUN_CALL(clear, x);
m_sample.clear();
m_sampleSize = intGentor(m_sampleSizeRange);
Modified: sandbox/itl/boost/itl_xt/setgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/setgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/setgentor.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -81,7 +81,7 @@
void SetGentorT<SetTV>::some(SetTV& x)
{
NumberGentorT<int> intGentor;
- x.clear();
+ ITL_FUN_CALL(clear, x);
m_sample.clear();
m_sampleSize = intGentor(m_sampleSizeRange);
Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -108,7 +108,7 @@
if(_info_level >= inform::rarely)
reportFrequencies();
- return _violationsCount.empty();
+ return itl::is_empty(_violationsCount);
}
void validateType()
@@ -162,7 +162,7 @@
avg_evaluation_time_per_law, " total avg of atomic evaluation (micro sec)", instance_count, avg_evaluation_time_per_law);
int violation_count = 1;
- if(!_violations.empty())
+ if(!itl::is_empty(_violations))
{
std::cout << "------------------------------------------------------------------------------" << std::endl;
std::cout << "--- Law violations -----------------------------------------------count-------" << std::endl;
@@ -172,14 +172,14 @@
printf("%3d %-59s%8d\n", violation_count, it->first.c_str(), it->second.getViolationsCount());
violation_count++;
}
- if(!_violations.empty())
+ if(!itl::is_empty(_violations))
std::cout << "------------------------------------------------------------------------------" << std::endl;
ITL_FORALL(ViolationMapT, it, _violations)
{
PolyLawViolations violas = it->second;
violas.reportFirst();
}
- if(!_violations.empty())
+ if(!itl::is_empty(_violations))
std::cout << "------------------------------------------------------------------------------" << std::endl;
}
Modified: sandbox/itl/boost/validate/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl/functors.hpp (original)
+++ sandbox/itl/boost/validate/itl/functors.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -26,7 +26,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
ITL_const_FORALL(typename SourceT, item_, items)
collected.insert(*item_);
}
@@ -40,7 +40,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
prior_ = collected.insert(prior_, *item_);
@@ -55,7 +55,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
std::copy(items.begin(), items.end(), itl::inserter(collected, collected.end()));
}
};
@@ -69,7 +69,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
ITL_const_FORALL(typename SourceT, item_, items)
collected.add(*item_);
}
@@ -83,7 +83,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
prior_ = collected.add(prior_, *item_);
@@ -98,7 +98,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- collected.clear();
+ ITL_FUN_CALL(clear, collected);
std::copy(items.begin(), items.end(), itl::adder(collected, collected.end()));
}
};
Modified: sandbox/itl/boost/validate/laws/law_violations.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/law_violations.hpp (original)
+++ sandbox/itl/boost/validate/laws/law_violations.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -146,8 +146,8 @@
iterator end() { return _violations.end(); }
const_iterator end()const { return _violations.begin(); }
- void clear() { _violations.clear(); }
- bool empty()const { return _violations.empty(); }
+ void clear() { ITL_FUN_CALL(clear, _violations); }
+ bool empty()const { return ITL_FUN_REN(empty, is_empty, _violations); }
size_type size()const { return _violations.size(); }
void reportFirst()const
Modified: sandbox/itl/boost/validate/validater/law_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/law_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/law_validater.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -136,9 +136,9 @@
template <class LawT, template<typename>class GentorT>
void LawValidater<LawT, GentorT>::init()
{
- _frequencies.clear();
+ ITL_FUN_CALL(clear, _frequencies);
_lawViolations.clear();
- _violations.clear();
+ ITL_FUN_CALL(clear, _violations);
}
// Runs law_instance_count * repeat_count validations on the law LawT
Modified: sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -113,7 +113,7 @@
rightopen_interval<ptime> when = it->first;
// Who is at the party within the time interval 'when' ?
GuestSetT who = (*it++).second;
- cout << when << ": " << who << endl;
+ cout << when << ": " << who << endl;
}
}
Modified: sandbox/itl/libs/itl/example/interval_/interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_/interval.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_/interval.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -35,16 +35,16 @@
cout << "----------------------------------------------------\n";
discrete_interval<int> int_interval
- = construct<discrete_interval<int> >(3, 7, interval_bounds::closed());
+ = construct<discrete_interval<int> >(3, 7, interval_bounds::closed());
continuous_interval<double> sqrt_interval
- = construct<continuous_interval<double> >(1/sqrt(2.0), sqrt(2.0));
- //interval_bounds::right_open() is default
+ = construct<continuous_interval<double> >(1/sqrt(2.0), sqrt(2.0));
+ //interval_bounds::right_open() is default
continuous_interval<string> city_interval
- = construct<continuous_interval<string> >("Barcelona", "Boston", interval_bounds::left_open());
+ = construct<continuous_interval<string> >("Barcelona", "Boston", interval_bounds::left_open());
discrete_interval<Time> time_interval
- = construct<discrete_interval<Time> >(Time(monday,8,30), Time(monday,17,20),
- interval_bounds::open());
+ = construct<discrete_interval<Time> >(Time(monday,8,30), Time(monday,17,20),
+ interval_bounds::open());
cout << " discrete_interval<int>: " << int_interval << endl;
cout << "continuous_interval<double>: " << sqrt_interval << " does "
@@ -58,7 +58,7 @@
<< " contain 'Berlin'" << endl;
cout << " discrete_interval<Time>: " << time_interval << endl;
- return 0;
+ return 0;
}
// Program output:
Modified: sandbox/itl/libs/itl/example/man_power_/man_power.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/man_power_/man_power.cpp (original)
+++ sandbox/itl/libs/itl/example/man_power_/man_power.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -125,9 +125,9 @@
// Bodos additional absence times
discrete_interval<date> bodos_flu(from_string("2008-09-19"), from_string("2008-09-29"),
- interval_bounds::closed());
+ interval_bounds::closed());
discrete_interval<date> bodos_vacation(from_string("2008-08-15"), from_string("2008-09-03"),
- interval_bounds::closed());
+ interval_bounds::closed());
interval_set<date> bodos_absence_times(bodos_flu);
bodos_absence_times += bodos_vacation;
Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -214,10 +214,17 @@
*/
- //int found;
- //TargetT::reverse_iterator it = std::find(left.rbegin(), left.rend(), found); //!
+ discrete_interval<int> fst = discrete_interval<int>::open(1,3);
+ discrete_interval<int> itv = discrete_interval<int>::rightopen(0,3);
- bool incl = std::includes(left.rbegin(), left.rend(), right.rbegin(), right.rend(), std::greater<int>());
+ cout << "fst = " << fst << endl;
+ cout << "itv = " << itv << endl;
+ discrete_interval<int> lft = right_subtract(fst,itv);
+ cout << "lft = " << lft << endl;
+ if(itl::is_empty(lft))
+ cout << "is MT\n";
+ else
+ cout << "is NOT MT\n";
}
Modified: sandbox/itl/libs/itl/test/test_functions.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_functions.hpp (original)
+++ sandbox/itl/libs/itl/test/test_functions.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -13,6 +13,9 @@
#define BOOST_ITL_TEST_FUNCTIONS_H_JOFA_091003
#include <boost/itl/detail/notate.hpp>
+#include <boost/itl/type_traits/interval_type_of.hpp>
+#include <boost/itl/discrete_interval.hpp>
+
#include <boost/itl/type_traits/neutron.hpp>
#include <boost/itl/functors.hpp>
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -32,8 +32,9 @@
template <class T, class U>
void interval_map_mixed_equal_4_ordered_types()
{
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v0 = neutron<T>::value();
U u1 = unon<U>::value();
@@ -78,6 +79,7 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v0 = neutron<T>::value();
T v1 = unon<T>::value();
@@ -110,6 +112,8 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v1 = make<T>(1);
T v2 = make<T>(2);
@@ -118,13 +122,13 @@
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- 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);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
SplitIntervalMapT split_map;
split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
@@ -138,6 +142,8 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v1 = make<T>(1);
@@ -146,13 +152,13 @@
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- 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);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
SplitIntervalMapT split_map;
split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
@@ -168,6 +174,8 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v1 = make<T>(1);
@@ -176,13 +184,13 @@
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- 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);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
IntervalMapT join_map;
join_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
@@ -205,6 +213,8 @@
void partial_interval_map_mixed_inclusion_compare_4_bicremental_types()
{
typedef interval_map<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
//--------------------------------------------------------------------------
// equalities
// { 0 1 2 3 4 5 8 9 }
@@ -325,6 +335,7 @@
void partial_interval_map_mixed_contains_4_bicremental_types()
{
typedef interval_map<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
//--------------------------------------------------------------------------
// { 0 1 2 3 4 5 8 9 }
// {[0,2)[2,3](3,6) (7,9]}
@@ -451,8 +462,9 @@
template <class T, class U>
void interval_map_mixed_add_4_bicremental_types()
{
- typedef interval_map<T,U> IntervalMapT;
- typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
+ typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
U u1 = make<U>(1);
T v1 = make<T>(1);
@@ -461,13 +473,13 @@
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- 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);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, 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);
@@ -494,6 +506,8 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v1 = make<T>(1);
@@ -502,13 +516,13 @@
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
-
- 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);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
+
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I4_5D_1(I4_5D, 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);
@@ -534,8 +548,10 @@
template <class T, class U>
void interval_map_mixed_subtract_4_bicremental_types()
{
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
@@ -548,21 +564,21 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
SplitIntervalMapT split_map;
split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
@@ -618,6 +634,8 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
@@ -630,21 +648,21 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
SplitIntervalMapT split_map;
split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
@@ -698,10 +716,12 @@
template <class T, class U>
void interval_map_mixed_erase2_4_bicremental_types()
{
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
- typedef interval_set<T> IntervalSetT;
- typedef split_interval_set<T> SplitIntervalSetT;
+ typedef interval_set<T> IntervalSetT;
+ typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
@@ -714,21 +734,21 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
SplitIntervalMapT split_map;
split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
@@ -808,8 +828,10 @@
template <class T, class U>
void interval_map_mixed_insert_erase_4_bicremental_types()
{
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
@@ -822,21 +844,21 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
SplitIntervalMapT split_A, split_B, split_all, split_X;
IntervalMapT join_A, join_B, join_all, join_X;
@@ -901,8 +923,10 @@
{
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
- typedef interval_set<T> IntervalSetT;
+ typedef interval_set<T> IntervalSetT;
typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
@@ -915,21 +939,21 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
-
- std::pair<interval<T>,U> I0_4D_1(I0_4D, u1);
- std::pair<interval<T>,U> I2_6D_1(I2_6D, u1);
- std::pair<interval<T>,U> I3_6D_1(I3_6D, u1);
- std::pair<interval<T>,U> I5_7D_1(I5_7D, u1);
- std::pair<interval<T>,U> I7_8D_1(I7_8D, u1);
- std::pair<interval<T>,U> I8_9D_1(I8_9D, u1);
- std::pair<interval<T>,U> I8_9I_1(I8_9I, u1);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
+
+ std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
+ std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
+ std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
+ std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
+ std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
+ std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
+ std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
SplitIntervalMapT split_A, split_B, split_all, split_X;
IntervalMapT join_A, join_B, join_all, join_X;
@@ -1003,6 +1027,8 @@
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef interval_set<T> IntervalSetT;
typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
U u2 = make<U>(2);
U u3 = make<U>(3);
@@ -1018,27 +1044,27 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I1_8D_1(I1_8D, u1);
- std::pair<const interval<T>,U> I2_7D_1(I2_7D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_3(I2_3D, u3);
- std::pair<interval<T>,U> I6_7D_1(I6_7D, u1);
- std::pair<interval<T>,U> I6_7D_3(I6_7D, u3);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I1_8D_1(I1_8D, u1);
+ std::pair<const IntervalT,U> I2_7D_1(I2_7D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_3(I2_3D, u3);
+ std::pair<IntervalT,U> I6_7D_1(I6_7D, u1);
+ std::pair<IntervalT,U> I6_7D_3(I6_7D, u3);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
//--------------------------------------------------------------------------
// split_interval_map
@@ -1086,9 +1112,9 @@
split_AB = split_A;
split_AB &= mapping_pair<T,U>(v1,u1);
- split_AB += make_pair(interval<T>::open(v1,v7), u2);
+ split_AB += make_pair(IntervalT::open(v1,v7), u2);
split_ab2.clear();
- split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u2);
+ split_ab2 += make_pair(IntervalT::rightopen(v1,v7), u2);
BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
}
@@ -1101,6 +1127,8 @@
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef interval_set<T> IntervalSetT;
typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
U u2 = make<U>(2);
U u3 = make<U>(3);
@@ -1116,27 +1144,27 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I1_8D_1(I1_8D, u1);
- std::pair<interval<T>,U> I2_7D_1(I2_7D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_3(I2_3D, u3);
- std::pair<interval<T>,U> I6_7D_1(I6_7D, u1);
- std::pair<interval<T>,U> I6_7D_3(I6_7D, u3);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I1_8D_1(I1_8D, u1);
+ std::pair<IntervalT,U> I2_7D_1(I2_7D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_3(I2_3D, u3);
+ std::pair<IntervalT,U> I6_7D_1(I6_7D, u1);
+ std::pair<IntervalT,U> I6_7D_3(I6_7D, u3);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
//--------------------------------------------------------------------------
// split_interval_map
@@ -1182,10 +1210,10 @@
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- split_AB &= interval<T>(v1);
- split_AB += make_pair(interval<T>::open(v1,v7), u1);
+ split_AB &= IntervalT(v1);
+ split_AB += make_pair(IntervalT::open(v1,v7), u1);
split_ab2.clear();
- split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u1);
+ split_ab2 += make_pair(IntervalT::rightopen(v1,v7), u1);
BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
@@ -1208,7 +1236,9 @@
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef interval_set<T> IntervalSetT;
- typedef split_interval_set<T> SplitIntervalSetT;
+ typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
U u2 = make<U>(2);
@@ -1224,27 +1254,27 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_2D = interval<T>::rightopen(v1,v2);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_2D_1(I1_2D, u1);
- std::pair<interval<T>,U> I1_2D_2(I1_2D, u2);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_2(I2_3D, u2);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I5_8D_1(I5_8D, u1);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_2D = IntervalT::rightopen(v1,v2);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
+ std::pair<IntervalT,U> I1_2D_2(I1_2D, u2);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_2(I2_3D, u2);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I5_8D_1(I5_8D, u1);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
//--------------------------------------------------------------------------
// split_interval_set
@@ -1286,10 +1316,12 @@
template <class T, class U>
void interval_map_mixed_intersect2_4_bicremental_types()
{
- typedef interval_map<T,U> IntervalMapT;
+ typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
- typedef interval_set<T> IntervalSetT;
- typedef split_interval_set<T> SplitIntervalSetT;
+ typedef interval_set<T> IntervalSetT;
+ typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
U u2 = make<U>(2);
@@ -1305,27 +1337,27 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_2D = interval<T>::rightopen(v1,v2);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I1_2D_1(I1_2D, u1);
- std::pair<interval<T>,U> I1_2D_2(I1_2D, u2);
- std::pair<interval<T>,U> I1_3D_1(I1_3D, u1);
- std::pair<interval<T>,U> I1_3D_2(I1_3D, u2);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I2_3D_2(I2_3D, u2);
- std::pair<interval<T>,U> I2_4D_1(I2_4D, u1);
- std::pair<interval<T>,U> I5_8D_1(I5_8D, u1);
- std::pair<interval<T>,U> I6_8D_1(I6_8D, u1);
- std::pair<interval<T>,U> I6_8D_2(I6_8D, u2);
- std::pair<interval<T>,U> I6_9D_1(I6_9D, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_2D = IntervalT::rightopen(v1,v2);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
+ std::pair<IntervalT,U> I1_2D_2(I1_2D, u2);
+ std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
+ std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I2_3D_2(I2_3D, u2);
+ std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
+ std::pair<IntervalT,U> I5_8D_1(I5_8D, u1);
+ std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
+ std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
+ std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
//--------------------------------------------------------------------------
// split_interval_set
@@ -1370,6 +1402,8 @@
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef interval_set<T> IntervalSetT;
typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
T v2 = make<T>(2);
@@ -1377,19 +1411,19 @@
T v4 = make<T>(4);
T v6 = make<T>(6);
- interval<T> I0_2D = interval<T>::rightopen(v0,v2);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I3_4D = interval<T>::rightopen(v3,v4);
- interval<T> I4_4I = interval<T>::closed(v4,v4);
- interval<T> C4_6D = interval<T>::open(v4,v6);
- interval<T> I6_6I = interval<T>::closed(v6,v6);
-
- std::pair<interval<T>,U> I0_2D_1(I0_2D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I3_4D_1(I3_4D, u1);
- std::pair<interval<T>,U> I4_4I_1(I4_4I, u1);
- std::pair<interval<T>,U> C4_6D_1(C4_6D, u1);
- std::pair<interval<T>,U> I6_6I_1(I6_6I, u1);
+ IntervalT I0_2D = IntervalT::rightopen(v0,v2);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I4_4I = IntervalT::closed(v4,v4);
+ IntervalT C4_6D = IntervalT::open(v4,v6);
+ IntervalT I6_6I = IntervalT::closed(v6,v6);
+
+ std::pair<IntervalT,U> I0_2D_1(I0_2D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I3_4D_1(I3_4D, u1);
+ std::pair<IntervalT,U> I4_4I_1(I4_4I, u1);
+ std::pair<IntervalT,U> C4_6D_1(C4_6D, u1);
+ std::pair<IntervalT,U> I6_6I_1(I6_6I, u1);
//--------------------------------------------------------------------------
//split_A: [0 2) [4 4] [6 6]
@@ -1413,7 +1447,7 @@
{
bool operator()(const Type& value)const
{
- return value.first.size() > 1 ;
+ return itl::size(value.first) > 1 ;
}
};
@@ -1425,6 +1459,8 @@
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef interval_set<T> IntervalSetT;
typedef split_interval_set<T> SplitIntervalSetT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
U u1 = make<U>(1);
T v0 = make<T>(0);
T v2 = make<T>(2);
@@ -1432,19 +1468,19 @@
T v4 = make<T>(4);
T v6 = make<T>(6);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I3_4D = interval<T>::rightopen(v3,v4);
- interval<T> I4_4I = interval<T>::closed(v4,v4);
- interval<T> C4_6D = interval<T>::open(v4,v6);
- interval<T> I6_6I = interval<T>::closed(v6,v6);
-
- std::pair<interval<T>,U> I0_3D_1(I0_3D, u1);
- std::pair<interval<T>,U> I2_3D_1(I2_3D, u1);
- std::pair<interval<T>,U> I3_4D_1(I3_4D, u1);
- std::pair<interval<T>,U> I4_4I_1(I4_4I, u1);
- std::pair<interval<T>,U> C4_6D_1(C4_6D, u1);
- std::pair<interval<T>,U> I6_6I_1(I6_6I, u1);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I4_4I = IntervalT::closed(v4,v4);
+ IntervalT C4_6D = IntervalT::open(v4,v6);
+ IntervalT I6_6I = IntervalT::closed(v6,v6);
+
+ std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
+ std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
+ std::pair<IntervalT,U> I3_4D_1(I3_4D, u1);
+ std::pair<IntervalT,U> I4_4I_1(I4_4I, u1);
+ std::pair<IntervalT,U> C4_6D_1(C4_6D, u1);
+ std::pair<IntervalT,U> I6_6I_1(I6_6I, u1);
//--------------------------------------------------------------------------
//split_A: [0 2) [4 4] [6 6]
@@ -1467,6 +1503,8 @@
void interval_map_mixed_infix_plus_overload_4_bicremental_types()
{
typedef interval_map<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
+
interval_map<T,U> join_a;
split_interval_map<T,U> split_a;
Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -20,6 +20,7 @@
void interval_map_fundamentals_4_ordered_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::size_type size_T;
typedef typename IntervalMapT::difference_type diff_T;
@@ -32,9 +33,9 @@
//T v1 = unon<T>();
T v0 = neutron<T>::value();
T v1 = unon<T>::value();
- interval<T> I0_0I(v0);
- interval<T> I1_1I(v1);
- interval<T> I0_1I(v0,v1);
+ IntervalT I0_0I(v0);
+ IntervalT I1_1I(v1);
+ IntervalT I0_1I(v0, v1, interval_bounds::closed());
U u1 = unon<U>::value();
//-------------------------------------------------------------------------
@@ -47,8 +48,8 @@
BOOST_CHECK_EQUAL(IntervalMapT().iterative_size(), 0);
BOOST_CHECK_EQUAL(IntervalMapT(), IntervalMapT());
- interval<T> mt_interval = neutron<interval<T> >::value();
- BOOST_CHECK_EQUAL(mt_interval, interval<T>());
+ IntervalT mt_interval = neutron<IntervalT >::value();
+ BOOST_CHECK_EQUAL(mt_interval, IntervalT());
typename IntervalMapT::value_type mt_u1 = make_pair(mt_interval, u1);
IntervalMapT mt_map = neutron<IntervalMapT >::value();
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
@@ -60,7 +61,7 @@
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
(mt_map += mt_u1) += mt_u1;
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
- BOOST_CHECK_EQUAL(hull(mt_map), neutron<interval<T> >::value());
+ BOOST_CHECK_EQUAL(hull(mt_map), neutron<IntervalT >::value());
//subtracting emptieness
mt_map.subtract(mt_u1).subtract(mt_u1);
@@ -169,10 +170,11 @@
void interval_map_ctor_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v4 = make<T>(4);
U u2 = make<U>(2);
- interval<T> I4_4I(v4);
+ IntervalT I4_4I(v4);
typename IntervalMapT::domain_mapping_type v4_u2(v4,u2);
typename IntervalMapT::value_type I4_4I_u2(I4_4I,u2);
@@ -232,20 +234,21 @@
void interval_map_add_sub_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v0 = make<T>(0);
T v5 = make<T>(5);
T v6 = make<T>(6);
T v9 = make<T>(9);
U u1 = make<U>(1);
- interval<T> I5_6I(v5,v6);
- interval<T> I5_9I(v5,v9);
- interval<T> I0_9I = interval<T>::closed(v0, v9);
+ IntervalT I5_6I(v5,v6, interval_bounds::closed());
+ IntervalT I5_9I(v5,v9, interval_bounds::closed());
+ IntervalT I0_9I = IntervalT::closed(v0, v9);
typename IntervalMapT::domain_mapping_type v0_u1 = make_pair(v0, u1);
typename IntervalMapT::domain_mapping_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);
+ typename IntervalMapT::value_type I0_9I_u1 = make_pair(IntervalT::closed(v0, v9), u1);
BOOST_CHECK_EQUAL( IntervalMapT(I5_6I_u1).add(v0_u1).add(v9_u1),
IntervalMapT().add(v9_u1).add(I5_6I_u1).add(v0_u1) );
@@ -285,6 +288,7 @@
void interval_map_distinct_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMap<T,U>::size_type size_T;
typedef typename IntervalMap<T,U>::difference_type diff_T;
T v1 = make<T>(1);
@@ -318,6 +322,7 @@
void interval_map_distinct_4_bicremental_continuous_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::size_type size_T;
typedef typename IntervalMapT::difference_type diff_T;
T v1 = make<T>(1);
@@ -346,10 +351,10 @@
IntervalMapT is_123_5;
is_123_5 = is_1_3_5;
//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
+ //is_123_5 += make_pair(IntervalT::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
+ //is_123_5 += make_pair<IntervalT, U>(IntervalT::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);
+ is_123_5 += typename IntervalMapT::value_type(IntervalT::open(v1,v3),u1);
//USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
BOOST_CHECK_EQUAL( is_123_5.cardinality(), itl::infinity<size_T>::value() );
@@ -370,6 +375,7 @@
void interval_map_isolate_4_bicremental_continuous_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::size_type size_T;
typedef typename IntervalMapT::difference_type diff_T;
@@ -377,9 +383,9 @@
T v2 = make<T>(2);
T v4 = make<T>(4);
U u1 = make<U>(1);
- interval<T> I0_4I = interval<T>::closed(v0,v4);
- interval<T> C0_2D = interval<T>::open(v0,v2);
- interval<T> C2_4D = interval<T>::open(v2,v4);
+ IntervalT I0_4I = IntervalT::closed(v0,v4);
+ IntervalT C0_2D = IntervalT::open(v0,v2);
+ IntervalT C2_4D = IntervalT::open(v2,v4);
typename IntervalMapT::value_type I0_4I_u1(I0_4I,u1);
typename IntervalMapT::value_type C0_2D_u1(C0_2D,u1);
typename IntervalMapT::value_type C2_4D_u1(C2_4D,u1);
@@ -423,6 +429,7 @@
void interval_map_contains_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::set_type IntervalSetT;
IntervalMapT itv_map; itv_map.add(K_v(3,1));
BOOST_CHECK_EQUAL( itv_map.contains(MK_v(3)), true );
@@ -465,6 +472,7 @@
void interval_map_contains_key_objects_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::set_type IntervalSetT;
IntervalMapT itv_map;
@@ -505,6 +513,7 @@
void interval_map_operators_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v0 = make<T>(0);
T v1 = make<T>(1);
T v3 = make<T>(3);
@@ -512,10 +521,10 @@
T v7 = make<T>(7);
T v8 = make<T>(8);
U u1 = make<U>(1);
- typename IntervalMapT::interval_type I3_5I(interval<T>::closed(v3,v5));
- typename IntervalMapT::value_type I0_1I_u1(interval<T>::closed(v0,v1),u1);
- typename IntervalMapT::value_type I3_5I_u1(interval<T>::closed(v3,v5),u1);
- typename IntervalMapT::value_type I7_8I_u1(interval<T>::closed(v7,v8),u1);
+ typename IntervalMapT::interval_type I3_5I(IntervalT::closed(v3,v5));
+ typename IntervalMapT::value_type I0_1I_u1(IntervalT::closed(v0,v1),u1);
+ typename IntervalMapT::value_type I3_5I_u1(IntervalT::closed(v3,v5),u1);
+ typename IntervalMapT::value_type I7_8I_u1(IntervalT::closed(v7,v8),u1);
IntervalMapT left, left2, right, all, section, complement;
left.add(I0_1I_u1).add(I3_5I_u1);
@@ -547,6 +556,7 @@
void interval_map_base_intersect_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v0 = make<T>(0);
T v1 = make<T>(1);
@@ -561,16 +571,16 @@
U u1 = make<U>(1);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_4D = interval<T>::rightopen(v1,v4);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_4D = IntervalT::rightopen(v1,v4);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
typename IntervalMapT::value_type I6_9D_1(I6_9D, u1);
@@ -653,6 +663,7 @@
void interval_map_base_erase_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
T v0 = make<T>(0);
T v1 = make<T>(1);
@@ -667,22 +678,22 @@
U u1 = make<U>(1);
- interval<T> I0_1D = interval<T>::rightopen(v0,v1);
- interval<T> I0_2D = interval<T>::rightopen(v0,v2);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_4D = interval<T>::rightopen(v1,v4);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
- interval<T> I7_9D = interval<T>::rightopen(v7,v9);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
+ IntervalT I0_1D = IntervalT::rightopen(v0,v1);
+ IntervalT I0_2D = IntervalT::rightopen(v0,v2);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_4D = IntervalT::rightopen(v1,v4);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
+ IntervalT I7_9D = IntervalT::rightopen(v7,v9);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
@@ -770,6 +781,7 @@
void interval_map_base_is_disjoint_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMap<T,U>::interval_set_type IntervalSetT;
T v0 = make<T>(0);
@@ -783,12 +795,12 @@
U u1 = make<U>(1);
- interval<T> I0_1D = interval<T>::rightopen(v0,v1);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
+ IntervalT I0_1D = IntervalT::rightopen(v0,v1);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
typename IntervalMapT::value_type I1_3D_1(I1_3D, u1);
@@ -854,6 +866,7 @@
void interval_map_flip_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef IntervalMapT IMap;
IntervalMapT set_a;
@@ -865,6 +878,7 @@
// 1 1
//BOOST_CHECK_EQUAL(IMap(IDv(0,2,1)) ^= (IDv(1,3,1)), IMap(IDv(0,1,1)) + IDv(2,3,1));
set_a = IMap(IDv(0,2,1));
+ IntervalMapT set_b = set_a;
BOOST_CHECK_EQUAL(set_a ^= IDv(1,3,1), IMap(IDv(0,1,1)) + IDv(2,3,1));
}
@@ -880,8 +894,9 @@
void interval_map_infix_plus_overload_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
IntervalMapT map_a, map_b;
@@ -907,8 +922,9 @@
void interval_map_infix_pipe_overload_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
IntervalMapT map_a, map_b;
@@ -936,12 +952,13 @@
void interval_map_infix_minus_overload_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
- itl::interval<T> itv = C_D(4,11);
+ IntervalT itv = C_D(4,11);
typename IntervalMapT::interval_mapping_type itv_v = CDv(4,11,3);
IntervalMapT map_a, map_b, map_c;
@@ -988,12 +1005,13 @@
void interval_map_infix_et_overload_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
- itl::interval<T> itv = C_D(4,11);
+ IntervalT itv = C_D(4,11);
IntervalMapT map_a, map_b;
map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
@@ -1037,12 +1055,13 @@
void interval_map_infix_caret_overload_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
- itl::interval<T> itv = C_D(4,11);
+ IntervalT itv = C_D(4,11);
IntervalMapT map_a, map_b;
map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
@@ -1076,9 +1095,10 @@
void interval_map_find_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
IntervalMapT map_a;
@@ -1108,9 +1128,10 @@
void interval_map_set_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
mapping_pair<T,U> map_pair = K_v(4,3);
IntervalMapT map_a;
@@ -1135,6 +1156,7 @@
void interval_map_inclusion_compare_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMap<T,U,Trt>::set_type IntervalSetT;
typedef itl::map<T,U,Trt> MapT;
typedef itl::set<T> SetT;
@@ -1206,9 +1228,10 @@
void interval_map_std_copy_via_inserter_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT; //Nedded for the test value generator
+ typedef typename IntervalMapT::interval_type IntervalT;
// Check equality of copying using handcoded loop or std::copy via inserter.
- typedef std::pair<interval<T>, U> SegmentT;
+ typedef std::pair<IntervalT, U> SegmentT;
std::vector<SegmentT> seg_vec_a;
IntervalMapT std_copied_map;
@@ -1247,6 +1270,7 @@
void interval_map_element_iter_4_discrete_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
+ typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::element_iterator ReptatorT;
typedef std::vector<std::pair<T,U> > VectorT;
Modified: sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -11,6 +11,9 @@
template <class T>
void interval_set_mixed_ctor_4_ordered_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = neutron<T>::value();
split_interval_set<T> split_set(v0);
@@ -24,6 +27,9 @@
template <class T>
void interval_set_mixed_equal_4_ordered_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = neutron<T>::value();
split_interval_set<T> split_empty, split_single(v0);
@@ -88,6 +94,9 @@
template <class T>
void interval_set_mixed_assign_4_ordered_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = neutron<T>::value();
T v1 = unon<T>::value();
@@ -117,15 +126,18 @@
template <class T>
void interval_set_mixed_ctor_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v1 = make<T>(1);
T v2 = make<T>(2);
T v3 = make<T>(3);
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
split_interval_set<T> split_set;
split_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -147,15 +159,18 @@
template <class T>
void interval_set_mixed_assign_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v1 = make<T>(1);
T v2 = make<T>(2);
T v3 = make<T>(3);
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
split_interval_set<T> split_set;
split_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -182,15 +197,18 @@
template <class T>
void interval_set_mixed_equal_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v1 = make<T>(1);
T v2 = make<T>(2);
T v3 = make<T>(3);
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
interval_set<T> join_set;
join_set.add(I1_3D).add(I2_4D).add(I4_5D);
@@ -222,6 +240,9 @@
template <class T>
void interval_set_mixed_contains_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
split_interval_set<T> split_set;
split_set.add(I_D(0,4)).add(I_D(4,8));
BOOST_CHECK_EQUAL( split_set.contains(MK_v(4)), true );
@@ -239,15 +260,18 @@
template <class T>
void interval_set_mixed_add_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v1 = make<T>(1);
T v2 = make<T>(2);
T v3 = make<T>(3);
T v4 = make<T>(4);
T v5 = make<T>(5);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I4_5D = interval<T>::rightopen(v4,v5);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I4_5D = IntervalT::rightopen(v4,v5);
split_interval_set<T> split_set;
split_set.add(I1_3D).add(I2_4D);
@@ -286,6 +310,9 @@
template <class T>
void interval_set_mixed_subtract_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = make<T>(0);
T v2 = make<T>(2);
T v3 = make<T>(3);
@@ -296,13 +323,13 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
split_interval_set<T> split_set;
split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
@@ -394,6 +421,9 @@
template <class T>
void interval_set_mixed_erase_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = make<T>(0);
T v2 = make<T>(2);
T v3 = make<T>(3);
@@ -404,13 +434,13 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_4D = interval<T>::rightopen(v0,v4);
- interval<T> I2_6D = interval<T>::rightopen(v2,v6);
- interval<T> I3_6D = interval<T>::rightopen(v3,v6);
- interval<T> I5_7D = interval<T>::rightopen(v5,v7);
- interval<T> I7_8D = interval<T>::rightopen(v7,v8);
- interval<T> I8_9D = interval<T>::rightopen(v8,v9);
- interval<T> I8_9I = interval<T>::closed(v8,v9);
+ IntervalT I0_4D = IntervalT::rightopen(v0,v4);
+ IntervalT I2_6D = IntervalT::rightopen(v2,v6);
+ IntervalT I3_6D = IntervalT::rightopen(v3,v6);
+ IntervalT I5_7D = IntervalT::rightopen(v5,v7);
+ IntervalT I7_8D = IntervalT::rightopen(v7,v8);
+ IntervalT I8_9D = IntervalT::rightopen(v8,v9);
+ IntervalT I8_9I = IntervalT::closed(v8,v9);
split_interval_set<T> split_set;
split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
@@ -501,6 +531,9 @@
template <class T>
void interval_set_mixed_basic_intersect_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = make<T>(0);
T v1 = make<T>(1);
T v2 = make<T>(2);
@@ -510,14 +543,14 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
//--------------------------------------------------------------------------
// split_interval_set
@@ -558,9 +591,9 @@
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB &= v1) += interval<T>::open(v1,v7);
+ (split_AB &= v1) += IntervalT::open(v1,v7);
split_ab2.clear();
- split_ab2 += interval<T>::rightopen(v1,v7);
+ split_ab2 += IntervalT::rightopen(v1,v7);
BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
}
@@ -568,6 +601,9 @@
template <class T>
void interval_set_mixed_intersect_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = make<T>(0);
T v1 = make<T>(1);
T v2 = make<T>(2);
@@ -579,14 +615,14 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_2D = interval<T>::rightopen(v1,v2);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- interval<T> I5_8D = interval<T>::rightopen(v5,v8);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_2D = IntervalT::rightopen(v1,v2);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I2_4D = IntervalT::rightopen(v2,v4);
+ IntervalT I5_8D = IntervalT::rightopen(v5,v8);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
//--------------------------------------------------------------------------
// split_interval_set
@@ -702,18 +738,21 @@
template <class T>
void interval_set_mixed_disjoint_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = make<T>(0);
T v2 = make<T>(2);
T v3 = make<T>(3);
T v4 = make<T>(4);
T v6 = make<T>(6);
- interval<T> I0_2D = interval<T>::rightopen(v0,v2);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I3_4D = interval<T>::rightopen(v3,v4);
- interval<T> I4_4I = interval<T>::closed(v4,v4);
- interval<T> C4_6D = interval<T>::open(v4,v6);
- interval<T> I6_6I = interval<T>::closed(v6,v6);
+ IntervalT I0_2D = IntervalT::rightopen(v0,v2);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I3_4D = IntervalT::rightopen(v3,v4);
+ IntervalT I4_4I = IntervalT::closed(v4,v4);
+ IntervalT C4_6D = IntervalT::open(v4,v6);
+ IntervalT I6_6I = IntervalT::closed(v6,v6);
//--------------------------------------------------------------------------
//split_A: [0 2) [4 4] [6 6]
@@ -742,6 +781,9 @@
template <class T>
void interval_set_mixed_infix_plus_overload_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
interval_set<T> join_a;
separate_interval_set<T> sep_a;
split_interval_set<T> split_a;
@@ -757,6 +799,9 @@
template <class T> void interval_set_mixed_infix_pipe_overload_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
interval_set<T> join_a;
separate_interval_set<T> sep_a;
split_interval_set<T> split_a;
@@ -773,6 +818,9 @@
template <class T>
void interval_set_mixed_infix_minus_overload_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
interval_set<T> join_a, join_b;
separate_interval_set<T> sep_a, sep_b;
split_interval_set<T> split_a, split_b;
@@ -792,6 +840,9 @@
template <class T> void interval_set_mixed_infix_et_overload_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
interval_set<T> join_a;
separate_interval_set<T> sep_a;
split_interval_set<T> split_a;
@@ -807,6 +858,9 @@
template <class T> void interval_set_mixed_infix_caret_overload_4_bicremental_types()
{
+ typedef interval_set<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
interval_set<T> join_a;
separate_interval_set<T> sep_a;
split_interval_set<T> split_a;
Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -17,6 +17,8 @@
class T>
void interval_set_fundamentals_4_ordered_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
@@ -27,9 +29,9 @@
T v0 = neutron<T>::value();
T v1 = unon<T>::value();
- interval<T> I0_0I(v0);
- interval<T> I1_1I(v1);
- interval<T> I0_1I(v0,v1);
+ IntervalT I0_0I(v0);
+ IntervalT I1_1I(v1);
+ IntervalT I0_1I(v0, v1, interval_bounds::closed());
//-------------------------------------------------------------------------
//empty set
@@ -41,8 +43,8 @@
BOOST_CHECK_EQUAL(IntervalSet<T>().iterative_size(), 0);
BOOST_CHECK_EQUAL(IntervalSet<T>(), IntervalSet<T>());
- interval<T> mt_interval = neutron<interval<T> >::value();
- BOOST_CHECK_EQUAL(mt_interval, interval<T>());
+ IntervalT mt_interval = neutron<IntervalT >::value();
+ BOOST_CHECK_EQUAL(mt_interval, IntervalT());
IntervalSet<T> mt_set = neutron<IntervalSet<T> >::value();
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
@@ -53,7 +55,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), neutron<interval<T> >::value());
+ BOOST_CHECK_EQUAL(hull(mt_set), neutron<IntervalT >::value());
//subtracting emptieness
mt_set.subtract(mt_interval).subtract(mt_interval);
@@ -148,8 +150,11 @@
class T>
void interval_set_ctor_4_bicremental_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v4 = make<T>(4);
- interval<T> I4_4I(v4);
+ IntervalT I4_4I(v4);
IntervalSet<T> _I4_4I;
BOOST_CHECK_EQUAL( _I4_4I.empty(), true );
@@ -199,13 +204,16 @@
class T>
void interval_set_add_sub_4_bicremental_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
+
T v0 = make<T>(0);
T v5 = make<T>(5);
T v6 = make<T>(6);
T v9 = make<T>(9);
- interval<T> I5_6I(v5,v6);
- interval<T> I5_9I(v5,v9);
- interval<T> I0_9I = interval<T>::closed(v0, v9);
+ IntervalT I5_6I(v5,v6,interval_bounds::closed());
+ IntervalT I5_9I(v5,v9,interval_bounds::closed());
+ IntervalT I0_9I = IntervalT::closed(v0, v9);
BOOST_CHECK_EQUAL( IntervalSet<T>(I5_6I).add(v0).add(v9),
IntervalSet<T>().insert(v9).insert(I5_6I).insert(v0) );
@@ -240,6 +248,8 @@
class T>
void interval_set_distinct_4_bicremental_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
T v1 = make<T>(1);
@@ -267,6 +277,8 @@
class T>
void interval_set_distinct_4_bicremental_continuous_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
T v1 = make<T>(1);
@@ -290,7 +302,7 @@
IntervalSet<T> is_123_5;
is_123_5 = is_1_3_5;
- is_123_5 += interval<T>::open(v1,v3);
+ is_123_5 += IntervalT::open(v1,v3);
BOOST_CHECK_EQUAL( is_123_5.cardinality(), itl::infinity<size_T>::value() );
BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
@@ -306,15 +318,17 @@
class T>
void interval_set_isolate_4_bicremental_continuous_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
T v0 = make<T>(0);
T v2 = make<T>(2);
T v4 = make<T>(4);
- interval<T> I0_4I = interval<T>::closed(v0,v4);
- interval<T> C0_2D = interval<T>::open(v0,v2);
- interval<T> C2_4D = interval<T>::open(v2,v4);
+ IntervalT I0_4I = IntervalT::closed(v0,v4);
+ IntervalT C0_2D = IntervalT::open(v0,v2);
+ IntervalT C2_4D = IntervalT::open(v2,v4);
// {[0 4]}
// - { (0,2) (2,4) }
// = {[0] [2] [4]}
@@ -352,6 +366,7 @@
void interval_set_element_compare_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef IntervalSet<T> ISet;
BOOST_CHECK_EQUAL( is_element_equal( ISet(), ISet()), true );
@@ -396,6 +411,8 @@
class T>
void interval_set_contains_4_bicremental_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
//LAW: x.add(e).contains(e);
//LAW: z = x + y => z.contains(x) && z.contains(y);
T v1 = make<T>(1);
@@ -410,17 +427,17 @@
BOOST_CHECK_EQUAL( IntervalSet<T>().add(make<T>(2)).contains(make<T>(2)), true );
BOOST_CHECK_EQUAL( IntervalSet<T>().insert(make<T>(2)).contains(make<T>(2)), true );
- BOOST_CHECK_EQUAL( (is += interval<T>(v3,v7)).contains(interval<T>(v3,v7)), true );
+ BOOST_CHECK_EQUAL( (is += IntervalT(v3,v7)).contains(IntervalT(v3,v7)), true );
IntervalSet<T> is0 = is;
- IntervalSet<T> is2(interval<T>::closed(v5,v8));
+ IntervalSet<T> is2(IntervalT::closed(v5,v8));
is2.add(v9).add(v11);
is += is2;
BOOST_CHECK_EQUAL( is.contains(is2), true );
is = is0;
- IntervalSet<T> is3(interval<T>::closed(v5,v8));
+ IntervalSet<T> is3(IntervalT::closed(v5,v8));
is3.insert(v9).insert(v11);
is += is3;
BOOST_CHECK_EQUAL( is.contains(is3), true );
@@ -435,6 +452,8 @@
class T>
void interval_set_operators_4_bicremental_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
T v0 = make<T>(0);
T v1 = make<T>(1);
T v3 = make<T>(3);
@@ -442,8 +461,8 @@
T v7 = make<T>(7);
T v8 = make<T>(8);
IntervalSet<T> left, left2, right, all, all2, section, complement, naught;
- left.add(interval<T>::closed(v0,v1)).add(interval<T>::closed(v3,v5));
- (right += interval<T>::closed(v3,v5)) += interval<T>::closed(v7,v8);
+ left.add(IntervalT::closed(v0,v1)).add(IntervalT::closed(v3,v5));
+ (right += IntervalT::closed(v3,v5)) += IntervalT::closed(v7,v8);
BOOST_CHECK_EQUAL( is_disjoint(left, right), false );
@@ -479,6 +498,8 @@
class T>
void interval_set_base_intersect_4_bicremental_types()
{
+ typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
T v0 = make<T>(0);
T v1 = make<T>(1);
T v2 = make<T>(2);
@@ -488,14 +509,14 @@
T v8 = make<T>(8);
T v9 = make<T>(9);
- interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- interval<T> I1_3D = interval<T>::rightopen(v1,v3);
- interval<T> I1_8D = interval<T>::rightopen(v1,v8);
- interval<T> I2_7D = interval<T>::rightopen(v2,v7);
- interval<T> I2_3D = interval<T>::rightopen(v2,v3);
- interval<T> I6_7D = interval<T>::rightopen(v6,v7);
- interval<T> I6_8D = interval<T>::rightopen(v6,v8);
- interval<T> I6_9D = interval<T>::rightopen(v6,v9);
+ IntervalT I0_3D = IntervalT::rightopen(v0,v3);
+ IntervalT I1_3D = IntervalT::rightopen(v1,v3);
+ IntervalT I1_8D = IntervalT::rightopen(v1,v8);
+ IntervalT I2_7D = IntervalT::rightopen(v2,v7);
+ IntervalT I2_3D = IntervalT::rightopen(v2,v3);
+ IntervalT I6_7D = IntervalT::rightopen(v6,v7);
+ IntervalT I6_8D = IntervalT::rightopen(v6,v8);
+ IntervalT I6_9D = IntervalT::rightopen(v6,v9);
//--------------------------------------------------------------------------
// IntervalSet
@@ -536,9 +557,9 @@
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB &= v1) += interval<T>::open(v1,v7);
+ (split_AB &= v1) += IntervalT::open(v1,v7);
split_ab2.clear();
- split_ab2 += interval<T>::rightopen(v1,v7);
+ split_ab2 += IntervalT::rightopen(v1,v7);
BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
}
@@ -553,6 +574,7 @@
void interval_set_flip_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef IntervalSetT ISet;
IntervalSetT set_a, set_b, lhs, rhs;
@@ -592,7 +614,8 @@
void interval_set_infix_plus_overload_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+ IntervalT itv = I_D(3,5);
IntervalSetT set_a, set_b;
set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -614,7 +637,9 @@
void interval_set_infix_pipe_overload_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
IntervalSetT set_a, set_b;
set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -637,7 +662,9 @@
void interval_set_infix_minus_overload_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
IntervalSetT set_a, set_b;
set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -659,7 +686,9 @@
void interval_set_infix_et_overload_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
IntervalSetT set_a, set_b;
set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -682,7 +711,9 @@
void interval_set_infix_caret_overload_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
IntervalSetT set_a, set_b;
set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
@@ -705,7 +736,9 @@
void interval_set_find_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef typename IntervalSetT::interval_type IntervalT;
+
+ IntervalT itv = I_D(3,5);
IntervalSetT set_a;
set_a.add(C_D(1,3)).add(I_I(6,11));
@@ -728,6 +761,7 @@
void interval_set_element_iter_4_discrete_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef std::vector<T> VectorT;
IntervalSetT set_a;
Modified: sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -22,6 +22,7 @@
void interval_set_check_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
IntervalSetT set_a, set_b, set_c;
set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -45,6 +46,7 @@
void interval_set_check_monoid_et_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
IntervalSetT set_a, set_b, set_c;
set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -72,6 +74,7 @@
void interval_set_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
IntervalSetT set_a, set_b, set_c;
set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -95,6 +98,7 @@
void interval_set_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
IntervalSetT set_a, set_b, set_c;
set_a.add(I_D(3,6)).add(I_I(5,7));
@@ -122,6 +126,7 @@
void interval_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
IntervalSetT set_a, set_b, set_c;
set_a.add(I_D(3,6)).add(I_I(5,7));
Modified: sandbox/itl/libs/itl/test/test_set_itl_set.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_itl_set.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_itl_set.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -22,6 +22,7 @@
void itl_set_check_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef itl::set<T> SetT;
IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -52,6 +53,7 @@
void itl_set_check_monoid_et_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef itl::set<T> SetT;
IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -85,6 +87,7 @@
void itl_set_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef itl::set<T> SetT;
IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -114,6 +117,7 @@
void itl_set_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef itl::set<T> SetT;
IntervalSetT itv_set_a, itv_set_b, itv_set_c;
@@ -147,6 +151,7 @@
void itl_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
+ typedef typename IntervalSetT::interval_type IntervalT;
typedef itl::set<T> SetT;
IntervalSetT itv_set_a, itv_set_b, itv_set_c;
Modified: sandbox/itl/libs/itl/test/test_value_maker.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_value_maker.hpp (original)
+++ sandbox/itl/libs/itl/test/test_value_maker.hpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -83,10 +83,11 @@
typedef typename ItvMapT::domain_mapping_type domain_mapping_type;
typedef std::pair<domain_type, codomain_type> std_pair_type;
- static interval<domain_type> interval_(int lower, int upper, int bounds = 2)
+ 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), static_cast<bound_type>(bounds));
+ test_value<domain_type>::make(upper), interval_bounds(bounds));
+ //CL test_value<domain_type>::make(upper), static_cast<bound_type>(bounds));
}
static value_type val_pair(int lower, int upper, int val, int bounds = 2)
@@ -111,13 +112,13 @@
// Very short value denotation for intervals
// Assumption typename T existes in scope
//I_I : [a,b]
-#define I_I(low,up) itl::interval<T>::closed (make<T>(low), make<T>(up))
+#define I_I(low,up) IntervalT::closed (make<T>(low), make<T>(up))
//I_D : [a,b)
-#define I_D(low,up) itl::interval<T>::rightopen(make<T>(low), make<T>(up))
+#define I_D(low,up) IntervalT::rightopen(make<T>(low), make<T>(up))
//C_I : (a,b]
-#define C_I(low,up) itl::interval<T>::leftopen (make<T>(low), make<T>(up))
+#define C_I(low,up) IntervalT::leftopen (make<T>(low), make<T>(up))
//C_D : (a,b)
-#define C_D(low,up) itl::interval<T>::open (make<T>(low), make<T>(up))
+#define C_D(low,up) IntervalT::open (make<T>(low), make<T>(up))
#define MK_v(key) make<T>(key)
#define MK_u(key) make<U>(key)
Modified: sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp (original)
+++ sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -21,7 +21,7 @@
int main()
{
- typedef InplaceCommutativity<itl::list<int> > TestLawT;
+ typedef InplaceCommutativity<itl::list<int> > TestLawT;
LawValidater<TestLawT> law_validator;
//-----------------------------------------------------------------------------
Modified: sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj
==============================================================================
--- sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj (original)
+++ sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -239,6 +239,10 @@
>
</Filter>
<File
+ RelativePath=".\ClassDiagram1.cd"
+ >
+ </File>
+ <File
RelativePath=".\ReadMe.txt"
>
</File>
Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2010-07-29 17:18:19 EDT (Thu, 29 Jul 2010)
@@ -75,15 +75,15 @@
//LawValidater<TestLawT> test_law;
-
- typedef FunctionEquality
- <
- itl::list<std::pair<rightopen_interval<double,std::less>,int> >, //SourceT,
- split_interval_map<double,int,partial_absorber>, //TargetT,
- base_insertion,
- hint_insertion
- >
- TestLawT;
+
+ typedef FunctionEquality
+ <
+ itl::list<std::pair<rightopen_interval<double,std::less>,int> >, //SourceT,
+ split_interval_map<double,int,partial_absorber>, //TargetT,
+ base_insertion,
+ hint_insertion
+ >
+ TestLawT;
LawValidater<TestLawT> test_law;
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