|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r61021 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/validate/driver libs/itl/doc libs/itl/example/large_bitset_ libs/itl/test libs/itl/test/fastest_itl_interval_ libs/itl/test/test_casual_ libs/itl/test/test_continuous_interval_ libs/itl/test/test_itl_interval_
From: afojgo_at_[hidden]
Date: 2010-04-03 11:50:52
Author: jofaber
Date: 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
New Revision: 61021
URL: http://svn.boost.org/trac/boost/changeset/61021
Log:
(1) Made the Interval template parameter configurable via macros. In this version, it can be switched between template template and template type style. But it's probably going to be template type finally because of the better possibilities to assign a default type dependent on the type of the domain_type.
(2) Added test code for continuous_interval.
Stable for msvc-9.0
Added:
sandbox/itl/boost/itl/type_traits/difference_type_of.hpp (contents, props changed)
sandbox/itl/boost/itl/type_traits/size_type_of.hpp (contents, props changed)
sandbox/itl/libs/itl/test/test_continuous_interval_/
sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp (contents, props changed)
sandbox/itl/libs/itl/test/test_continuous_interval_/vc9_test_continuous_interval.vcproj (contents, props changed)
sandbox/itl/libs/itl/test/test_interval_cases.hpp (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/continuous_interval.hpp | 39 +++++-----
sandbox/itl/boost/itl/detail/base_interval.hpp | 8 +-
sandbox/itl/boost/itl/detail/design_config.hpp | 20 +++++
sandbox/itl/boost/itl/detail/element_iterator.hpp | 136 ++++++++++++++++++++++++++++++-------
sandbox/itl/boost/itl/gregorian.hpp | 8 +-
sandbox/itl/boost/itl/interval.hpp | 51 +++++++------
sandbox/itl/boost/itl/interval_base_map.hpp | 79 ++++++++++-----------
sandbox/itl/boost/itl/interval_base_set.hpp | 48 ++++++------
sandbox/itl/boost/itl/interval_bounds.hpp | 54 +++++++++++++-
sandbox/itl/boost/itl/interval_functions.hpp | 112 +++++++++++++++++++++++++-----
sandbox/itl/boost/itl/interval_map.hpp | 60 ++++++++--------
sandbox/itl/boost/itl/interval_set.hpp | 22 +++---
sandbox/itl/boost/itl/ptime.hpp | 8 +-
sandbox/itl/boost/itl/separate_interval_set.hpp | 18 ++--
sandbox/itl/boost/itl/split_interval_map.hpp | 50 ++++++------
sandbox/itl/boost/itl/split_interval_set.hpp | 28 +++---
sandbox/itl/boost/validate/driver/itl_set_driver.hpp | 2
sandbox/itl/libs/itl/doc/acknowledgments.qbk | 2
sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp | 12 +-
sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp | 3
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 16 +++-
sandbox/itl/libs/itl/test/test_functions.hpp | 6
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 46 ++++++------
sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp | 16 ++--
sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp | 16 ++--
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 36 +++++-----
sandbox/itl/libs/itl/test/test_itl_interval.hpp | 13 +-
sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp | 2
sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp | 144 ++++++++++++++++++++++++++++++++++++++-
sandbox/itl/libs/itl/test/test_itl_map.hpp | 4
sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp | 16 ++--
sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 16 ++--
sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp | 10 +-
sandbox/itl/libs/itl/test/test_set_itl_set.hpp | 10 +-
sandbox/itl/libs/itl/test/vc9_slow_tests.sln | 6 +
35 files changed, 742 insertions(+), 375 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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -8,6 +8,8 @@
#ifndef BOOST_ITL_CONTINUOUS_INTERVAL_HPP_JOFA_100327
#define BOOST_ITL_CONTINUOUS_INTERVAL_HPP_JOFA_100327
+#include <boost/itl/type_traits/is_continuous.hpp>
+#include <boost/itl/type_traits/is_continuous_interval.hpp>
#include <boost/itl/detail/base_interval.hpp>
#include <boost/itl/interval_bounds.hpp>
#include <boost/itl/interval_functions.hpp>
@@ -31,35 +33,39 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
continuous_interval()
+ : _lwb(neutron<DomainT>::value()), _upb(neutron<DomainT>::value())
+ , _bounds(interval_bounds::right_open())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
+ //JODO URG BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
+ //JODO we must assert this via appropriate defaults for template parameters
}
//NOTE: Compiler generated copy constructor is used
/** Constructor for a closed singleton interval <tt>[val,val]</tt> */
explicit continuous_interval(const DomainT& val)
- : _lwb(val), _upb(val), _bounds(itl::closed_bounded)
+ : _lwb(val), _upb(val), _bounds(interval_bounds::closed())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
+ //JODO BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
continuous_interval(const DomainT& low, const DomainT& up,
- itl::bound_type bounds = itl::closed_bounded)
+ interval_bounds bounds = interval_bounds::right_open())
: _lwb(low), _upb(up), _bounds(bounds)
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+ //JODO BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
}
- domain_type lower()const { return _lwb; }
- domain_type upper()const { return _upb; }
- bound_type bounds()const{ return _bounds; }
+ domain_type lower()const { return _lwb; }
+ domain_type upper()const { return _upb; }
+ interval_bounds bounds()const{ return _bounds; }
domain_type first()const{ return _lwb; }
@@ -70,9 +76,9 @@
}
private:
- domain_type _lwb;
- domain_type _upb;
- bound_type _bounds;
+ domain_type _lwb;
+ domain_type _upb;
+ interval_bounds _bounds;
};
@@ -99,21 +105,18 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct has_dynamic_bounds<continuous_interval<DomainT,Compare> >
+struct is_continuous_interval<continuous_interval<DomainT,Compare> >
{
- typedef has_dynamic_bounds<continuous_interval<DomainT,Compare> > type;
- BOOST_STATIC_CONSTANT(bool, value = true);
+ typedef is_continuous_interval<continuous_interval<DomainT,Compare> > type;
+ BOOST_STATIC_CONSTANT(bool, value = is_continuous<DomainT>::value);
};
-
-/*CL JODO has_domain needed?
template <class DomainT, ITL_COMPARE Compare>
-struct has_domain<continuous_interval<DomainT,Compare> >
+struct has_dynamic_bounds<continuous_interval<DomainT,Compare> >
{
- typedef has_domain<continuous_interval<DomainT,Compare> > type;
+ typedef has_dynamic_bounds<continuous_interval<DomainT,Compare> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-*/
template <class DomainT, ITL_COMPARE Compare>
struct type_to_string<itl::continuous_interval<DomainT,Compare> >
Modified: sandbox/itl/boost/itl/detail/base_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/base_interval.hpp (original)
+++ sandbox/itl/boost/itl/detail/base_interval.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -12,8 +12,8 @@
#include <boost/call_traits.hpp>
#include <boost/concept_check.hpp>
#include <boost/itl/detail/design_config.hpp>
-#include <boost/itl/type_traits/difference.hpp>
-#include <boost/itl/type_traits/size.hpp>
+#include <boost/itl/type_traits/difference_type_of.hpp>
+#include <boost/itl/type_traits/size_type_of.hpp>
namespace boost{namespace itl
{
@@ -52,10 +52,10 @@
typedef domain_compare key_compare;
/// The difference type of an interval which is sometimes different form the domain_type
- typedef typename itl::difference<DomainT>::type difference_type;
+ typedef typename itl::difference_type_of<DomainT>::type difference_type;
/// The size type of an interval which is mostly std::size_t
- typedef typename itl::size<DomainT>::type size_type;
+ typedef typename itl::size_type_of<DomainT>::type size_type;
typedef typename boost::call_traits<DomainT>::param_type DomainP;
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -28,10 +28,12 @@
#define ITL_USE_COMPARE_TEMPLATE_TEMPLATE
#define ITL_USE_COMBINE_TEMPLATE_TEMPLATE
#define ITL_USE_SECTION_TEMPLATE_TEMPLATE
+//#define ITL_USE_INTERVAL_TEMPLATE_TEMPLATE
//#define ITL_USE_COMPARE_TEMPLATE_TYPE
//#define ITL_USE_COMBINE_TEMPLATE_TYPE
//#define ITL_USE_SECTION_TEMPLATE_TYPE
+#define ITL_USE_INTERVAL_TEMPLATE_TYPE
//------------------------------------------------------------------------------
// template parameter Compare can not be a template type parameter as long as
@@ -73,9 +75,25 @@
# define ITL_SECTION_INSTANCE(section_instance,codomain_type) section_instance<codomain_type>
#endif
+
+//------------------------------------------------------------------------------
+// template parameter Interval could be a template type parameter.
+#ifdef ITL_USE_INTERVAL_TEMPLATE_TEMPLATE
+# define ITL_INTERVAL(itl_compare) template<class,itl_compare>class
+# define ITL_INTERVAL2(itl_compare) template<class DomT2,itl_compare>class
+# define ITL_INTERVAL_TYPE(itl_interval, domain_type, itl_compare) itl_interval<domain_type,itl_compare>
+# define ITL_INTERVAL_INSTANCE(interval_instance,domain_type,itl_compare) interval_instance
+#else//ITL_USE_SECTION_TEMPLATE_TYPE
+# define ITL_INTERVAL(itl_compare) class
+# define ITL_INTERVAL2(itl_compare) class
+# define ITL_INTERVAL_TYPE(itl_interval, domain_type, itl_compare) itl_interval
+# define ITL_INTERVAL_INSTANCE(interval_instance,domain_type,itl_compare) interval_instance<domain_type,itl_compare>
+#endif
+
+
//------------------------------------------------------------------------------
//#define ITL_INTERVAL_DEFAULT itl::rightopen_interval
-#define ITL_INTERVAL_DEFAULT itl::interval
+#define ITL_INTERVAL_DEFAULT boost::itl::interval
//#define ITL_INTERVAL_DEFAULT itl::continuous_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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -73,28 +73,56 @@
template<class SegmentT>
struct elemental;
-template<class DomainT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval>
-struct elemental<Interval<DomainT,Compare> >
-{
- typedef Interval<DomainT,Compare> segment_type;
- typedef segment_type interval_type;
- typedef DomainT type;
- typedef DomainT domain_type;
- typedef DomainT codomain_type;
- typedef DomainT transit_type;
-};
+#ifdef ITL_USE_INTERVAL_TEMPLATE_TEMPLATE
-template< class DomainT, class CodomainT,
- ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval >
-struct elemental<std::pair<Interval<DomainT,Compare>const, CodomainT> >
-{
- typedef std::pair<Interval<DomainT,Compare>, CodomainT> segment_type;
- typedef Interval<DomainT,Compare> interval_type;
- typedef std::pair<DomainT, CodomainT> type;
- typedef DomainT domain_type;
- typedef CodomainT codomain_type;
- typedef mapped_reference<DomainT, CodomainT> transit_type;
-};
+ template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
+ struct elemental<ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >
+ {
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type;
+ typedef segment_type interval_type;
+ typedef DomainT type;
+ typedef DomainT domain_type;
+ typedef DomainT codomain_type;
+ typedef DomainT transit_type;
+ };
+
+ template< class DomainT, class CodomainT,
+ ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval >
+ struct elemental<std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+ {
+ typedef std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare), CodomainT> segment_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
+ typedef std::pair<DomainT, CodomainT> type;
+ typedef DomainT domain_type;
+ typedef CodomainT codomain_type;
+ typedef mapped_reference<DomainT, CodomainT> transit_type;
+ };
+
+#else //ITL_USE_INTERVAL_TEMPLATE_TYPE
+
+ template<ITL_INTERVAL(ITL_COMPARE) Interval>
+ struct elemental
+ {
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type;
+ typedef segment_type interval_type;
+ typedef typename interval_type::domain_type domain_type;
+ typedef domain_type type;
+ typedef domain_type codomain_type;
+ typedef domain_type transit_type;
+ };
+
+ template< class CodomainT, ITL_INTERVAL(ITL_COMPARE) Interval >
+ struct elemental<std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+ {
+ typedef std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare), CodomainT> segment_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
+ typedef typename interval_type::domain_type domain_type;
+ typedef CodomainT codomain_type;
+ typedef std::pair<domain_type, codomain_type> type;
+ typedef mapped_reference<domain_type, codomain_type> transit_type;
+ };
+
+#endif //ITL_USE_INTERVAL_TEMPLATE_TEMPLATE
//------------------------------------------------------------------------------
@@ -103,11 +131,13 @@
template<class SegmentIteratorT, class SegmentT>
struct segment_adapter;
-template<class SegmentIteratorT, class DomainT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval>
-struct segment_adapter<SegmentIteratorT, Interval<DomainT,Compare> >
+#ifdef ITL_USE_INTERVAL_TEMPLATE_TEMPLATE
+
+template<class SegmentIteratorT, class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
+struct segment_adapter<SegmentIteratorT, ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >
{
typedef segment_adapter type;
- typedef Interval<DomainT,Compare> segment_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type;
typedef segment_type interval_type;
typedef typename interval_type::difference_type domain_difference_type;
typedef DomainT domain_type;
@@ -129,11 +159,11 @@
};
template < class SegmentIteratorT, class DomainT, class CodomainT,
- ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval >
-struct segment_adapter<SegmentIteratorT, std::pair<Interval<DomainT,Compare>const, CodomainT> >
+ ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval >
+struct segment_adapter<SegmentIteratorT, std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
{
typedef segment_adapter type;
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
typedef typename interval_type::difference_type domain_difference_type;
typedef DomainT domain_type;
typedef std::pair<DomainT, CodomainT> element_type;
@@ -153,6 +183,58 @@
}
};
+#else // ITL_USE_INTERVAL_TEMPLATE_TYPE
+
+template<class SegmentIteratorT, ITL_INTERVAL(ITL_COMPARE) Interval>
+struct segment_adapter //CL <SegmentIteratorT, ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >
+{
+ typedef segment_adapter type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type;
+ typedef segment_type interval_type;
+ typedef typename interval_type::difference_type domain_difference_type;
+ typedef typename interval_type::domain_type domain_type;
+ typedef domain_type codomain_type;
+ typedef domain_type element_type;
+ typedef domain_type& transit_type;
+
+ 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 leaper->length();}
+
+ static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
+ const domain_difference_type& sneaker)
+ {
+ inter_pos = is_reverse<SegmentIteratorT>::value ? leaper->last() - sneaker
+ : leaper->first() + sneaker;
+ return inter_pos;
+ }
+};
+
+template < class SegmentIteratorT, class CodomainT, ITL_INTERVAL(ITL_COMPARE) Interval >
+struct segment_adapter<SegmentIteratorT, std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+{
+ typedef segment_adapter type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
+ typedef typename interval_type::domain_type domain_type;
+ typedef typename interval_type::difference_type domain_difference_type;
+ typedef CodomainT codomain_type;
+ typedef std::pair<domain_type, codomain_type> element_type;
+ typedef mapped_reference<domain_type, CodomainT> transit_type;
+
+ 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 leaper->first.length();}
+
+ static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
+ const domain_difference_type& sneaker)
+ {
+ inter_pos = is_reverse<SegmentIteratorT>::value ? leaper->first.last() - sneaker
+ : leaper->first.first() + sneaker;
+ return transit_type(inter_pos, leaper->second);
+ }
+};
+
+#endif // ITL_USE_INTERVAL_TEMPLATE_TEMPLATE
template <class SegmentIteratorT>
class element_iterator
Modified: sandbox/itl/boost/itl/gregorian.hpp
==============================================================================
--- sandbox/itl/boost/itl/gregorian.hpp (original)
+++ sandbox/itl/boost/itl/gregorian.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -25,8 +25,8 @@
#endif
#include <boost/itl/type_traits/neutron.hpp>
-#include <boost/itl/type_traits/difference.hpp>
-#include <boost/itl/type_traits/size.hpp>
+#include <boost/itl/type_traits/difference_type_of.hpp>
+#include <boost/itl/type_traits/size_type_of.hpp>
namespace boost{namespace itl
{
@@ -47,11 +47,11 @@
};
template<>
- struct difference<boost::gregorian::date>
+ struct difference_type_of<boost::gregorian::date>
{ typedef boost::gregorian::date_duration type; };
template<>
- struct size<boost::gregorian::date>
+ struct size_type_of<boost::gregorian::date>
{ typedef boost::gregorian::date_duration type; };
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -28,8 +28,8 @@
#include <boost/itl/type_traits/unon.hpp>
#include <boost/itl/type_traits/infinity.hpp>
#include <boost/itl/type_traits/is_continuous.hpp>
-#include <boost/itl/type_traits/difference.hpp>
-#include <boost/itl/type_traits/size.hpp>
+#include <boost/itl/type_traits/difference_type_of.hpp>
+#include <boost/itl/type_traits/size_type_of.hpp>
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/itl/type_traits/to_string.hpp>
#include <boost/itl/type_traits/is_universal_interval.hpp>
@@ -92,10 +92,10 @@
typedef domain_compare key_compare;
/// The difference type of an interval which is sometimes different form the domain_type
- typedef typename itl::difference<DomainT>::type difference_type;
+ typedef typename itl::difference_type_of<DomainT>::type difference_type;
/// The size type of an interval which is mostly std::size_t
- typedef typename itl::size<DomainT>::type size_type;
+ typedef typename itl::size_type_of<DomainT>::type size_type;
public:
//==========================================================================
@@ -955,7 +955,7 @@
// typename interval<DomainT,Compare>::size_type
template <class DomainT, ITL_COMPARE Compare>
-inline typename itl::size<DomainT>::type interval<DomainT,Compare>::cardinality()const
+inline typename itl::size_type_of<DomainT>::type interval<DomainT,Compare>::cardinality()const
{
using namespace boost::mpl;
return if_<
@@ -1060,9 +1060,9 @@
[a b) : left_over
\endcode
*/
-//CL template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval>
-//inline Interval<DomainT,Compare> right_subtract(Interval<DomainT,Compare> left,
-// const Interval<DomainT,Compare>& right_minuend)
+//CL template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
+//inline ITL_INTERVAL_TYPE(Interval,DomainT,Compare) right_subtract(ITL_INTERVAL_TYPE(Interval,DomainT,Compare) left,
+// const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& right_minuend)
//{
// return left.right_subtract(right_minuend);
//}
@@ -1076,9 +1076,9 @@
[c d) : right_over
\endcode
*/
-//CL template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval>
-//inline Interval<DomainT,Compare> left_subtract(Interval<DomainT,Compare> right,
-// const Interval<DomainT,Compare>& left_minuend)
+//CL template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
+//inline ITL_INTERVAL_TYPE(Interval,DomainT,Compare) left_subtract(ITL_INTERVAL_TYPE(Interval,DomainT,Compare) right,
+// const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& left_minuend)
//{
// return right.left_subtract(left_minuend);
//}
@@ -1088,9 +1088,9 @@
//==============================================================================
/** Returns the intersection of \c left and \c right interval. */
-//CL template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval>
-//inline Interval<DomainT,Compare> operator & (Interval<DomainT,Compare> left,
-// const Interval<DomainT,Compare>& right)
+//CL template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
+//inline ITL_INTERVAL_TYPE(Interval,DomainT,Compare) operator & (ITL_INTERVAL_TYPE(Interval,DomainT,Compare) left,
+// const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& right)
//{
// return left &= right;
//}
@@ -1116,16 +1116,17 @@
//==============================================================================
template <class DomainT, ITL_COMPARE Compare,
- template<class,ITL_COMPARE>class Interval>
-Interval<DomainT,Compare> inner_complement(const Interval<DomainT,Compare>& left,
- const Interval<DomainT,Compare>& right)
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+ITL_INTERVAL_TYPE(Interval,DomainT,Compare)
+ inner_complement(const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& left,
+ const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& right)
{
if(left.exclusive_less(right))
return hull(left, right).left_subtract(left).right_subtract(right);
else if(right.exclusive_less(left))
return hull(right, left).left_subtract(right).right_subtract(left);
else
- return neutron<Interval<DomainT,Compare> >::value();
+ return neutron<ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >::value();
}
//==============================================================================
@@ -1133,10 +1134,10 @@
//==============================================================================
template <class DomainT, ITL_COMPARE Compare,
- template<class,ITL_COMPARE>class Interval>
-inline typename Interval<DomainT,Compare>::difference_type
- distance(const Interval<DomainT,Compare>& left,
- const Interval<DomainT,Compare>& right)
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+inline typename ITL_INTERVAL_TYPE(Interval,DomainT,Compare)::difference_type
+ distance(const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& left,
+ const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& right)
{
using namespace boost::mpl;
return if_<
@@ -1148,9 +1149,9 @@
}
template <class DomainT, ITL_COMPARE Compare,
- template<class,ITL_COMPARE>class Interval>
-inline typename Interval<DomainT,Compare>::difference_type
- length(const Interval<DomainT,Compare>& inter_val)
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+inline typename ITL_INTERVAL_TYPE(Interval,DomainT,Compare)::difference_type
+ length(const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& inter_val)
{
using namespace boost::mpl;
return if_<
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -46,7 +46,6 @@
};
-
/** \brief Implements a map as a map of intervals (base class) */
template
<
@@ -57,7 +56,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
- template<class,ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class interval_base_map
@@ -98,7 +97,7 @@
/// Conceptual is a map a set of elements of type \c element_type
typedef domain_mapping_type element_type;
/// The interval type of the map
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
/// Auxiliary type for overload resolution
typedef std::pair<interval_type,CodomainT> interval_mapping_type;
/// Type of an interval containers segment, that is spanned by an interval
@@ -547,7 +546,7 @@
template
<
template
- <class DomT, ITL_COMPARE Comp, template<class DomT2, ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ <class DomT, ITL_COMPARE Comp, ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
class IntervalSet
>
void add_intersection
@@ -578,7 +577,7 @@
<
class DomT, class CodomT, class Trts,
ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc
+ ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc
>
class IntervalMap
>
@@ -731,7 +730,7 @@
template
<
template
- <class DomT, ITL_COMPARE Comp, template<class DomT2, ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ <class DomT, ITL_COMPARE Comp, ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
class IntervalSet
>
void domain(IntervalSet<DomainT,Compare,Interval,Alloc>& dom)const
@@ -865,7 +864,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
bool interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::contains(const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
@@ -899,7 +898,7 @@
<
class SubType, class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
typename interval_base_map<SubType,DomainT,CodomainT,Traits,
Compare,Combine,Section,Interval,Alloc>::size_type
@@ -919,7 +918,7 @@
<
class SubType, class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
typename interval_base_map<SubType,DomainT,CodomainT,Traits,
Compare,Combine,Section,Interval,Alloc>::difference_type
@@ -941,7 +940,7 @@
class SubType,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
template
<
@@ -949,7 +948,7 @@
<
class DomT, class CodomT, class Trts,
ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc
+ ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc
>
class IntervalMap
>
@@ -985,7 +984,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_intersection(interval_base_map& section,
@@ -1037,7 +1036,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_intersection(interval_base_map& section,
@@ -1066,7 +1065,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::flip(const segment_type& interval_value_pair)
@@ -1156,7 +1155,7 @@
class SubType,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
template<class SubType2>
SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
@@ -1211,7 +1210,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join()
@@ -1254,7 +1253,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
std::string interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::as_string()const
{
@@ -1274,7 +1273,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::sum(codomain_type& total)const
@@ -1288,7 +1287,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::uniform_bounds(itl::bound_type bounded)
{
@@ -1301,7 +1300,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase(const interval_type& minuend)
@@ -1354,7 +1353,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
SubType&
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
@@ -1370,7 +1369,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
template<class Predicate>
SubType&
@@ -1389,7 +1388,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
template<class Predicate>
SubType&
@@ -1417,7 +1416,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
@@ -1428,7 +1427,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool operator != (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
@@ -1440,7 +1439,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
@@ -1452,11 +1451,11 @@
template
<
class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc,
template
<
class, class, class,
- ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+ ITL_COMPARE, ITL_COMBINE, ITL_SECTION, ITL_INTERVAL(ITL_COMPARE), ITL_ALLOC
>
class IntervalMap
>
@@ -1477,21 +1476,21 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool operator < (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
{
return std::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<std::pair<Interval<DomainT,Compare>,CodomainT> >()//NOTE DESIGN TTP: Why template template parameter Compare is needed
+ Compare<std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare),CodomainT> >()//NOTE DESIGN TTP: Why template template parameter Compare is needed
);
}
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool operator > (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
@@ -1500,7 +1499,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool operator <= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
@@ -1509,7 +1508,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
inline bool operator >= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
@@ -1523,7 +1522,7 @@
class SubType,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>&
@@ -1548,7 +1547,7 @@
class SubType,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>&
@@ -1573,7 +1572,7 @@
template<class CharType, class CharTraits,
class SubType, class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
const interval_base_map<SubType,DomainT,CodomainT,Traits,
@@ -1595,7 +1594,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
struct is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
@@ -1606,7 +1605,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
struct is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
@@ -1617,7 +1616,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
struct has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
@@ -1628,7 +1627,7 @@
template
<
class SubType,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
struct is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -31,7 +31,7 @@
typename SubType,
typename DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- template<class, ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class interval_base_set
@@ -66,7 +66,7 @@
typedef DomainT element_type;
/// The interval type of the set
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
/// The segment type of the set
typedef interval_type segment_type;
@@ -198,7 +198,7 @@
template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
class IntervalSet
>
bool contains(const IntervalSet<DomainT,Compare,Interval,Alloc>& sub)const
@@ -208,7 +208,7 @@
template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
class IntervalSet
>
bool contained_in(const IntervalSet<DomainT,Compare,Interval,Alloc>& super)const
@@ -350,7 +350,7 @@
template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
class IntervalSet
>
void add_intersection
@@ -506,7 +506,7 @@
template
<
class SubType, class DomainT,
- ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
typename interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::size_type
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::cardinality()const
@@ -523,7 +523,7 @@
template
<
class SubType, class DomainT,
- ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
typename
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::difference_type
@@ -537,7 +537,7 @@
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::add_intersection(interval_base_set& section, const segment_type& inter_val)const
{
// any intersection with the empty intervall is empty
@@ -558,11 +558,11 @@
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ ITL_INTERVAL2(ITL_COMPARE) Interv, ITL_ALLOC Allc>
class IntervalSet
>
void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
@@ -593,7 +593,7 @@
//==============================================================================
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::flip(const segment_type& inter_val)
{
@@ -631,7 +631,7 @@
template
<
class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
template<class SubType2>
SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
@@ -665,7 +665,7 @@
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::join()
{
@@ -704,7 +704,7 @@
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>::uniform_bounds(itl::bound_type bounded)
{
// I can do this only, because I am sure that the contents and the
@@ -717,7 +717,7 @@
//= Equivalences and Orderings
//==============================================================================
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator == (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{
@@ -725,44 +725,44 @@
}
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator != (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{ return !(lhs == rhs); }
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator < (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{
return std::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<Interval<DomainT,Compare> >()//NOTE DESIGN TTP: Why Compare needs to be ttp
+ Compare<ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >()//NOTE DESIGN TTP: Why Compare needs to be ttp
);
}
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator > (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{ return rhs < lhs; }
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator <= (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{ return !(lhs > rhs); }
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator >= (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{ return !(lhs < rhs); }
template<class CharType, class CharTraits,
class SubType, class DomainT,
- ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object)
@@ -779,7 +779,7 @@
// type traits
//-----------------------------------------------------------------------------
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
@@ -787,7 +787,7 @@
};
template<class SubType,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
Modified: sandbox/itl/boost/itl/interval_bounds.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_bounds.hpp (original)
+++ sandbox/itl/boost/itl/interval_bounds.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -8,7 +8,8 @@
#ifndef BOOST_ITL_INTERVAL_BOUNDS_HPP_JOFA_100330
#define BOOST_ITL_INTERVAL_BOUNDS_HPP_JOFA_100330
-#include <boost/itl/detail/base_interval.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/itl/type_traits/has_dynamic_bounds.hpp>
namespace boost{namespace itl
{
@@ -30,19 +31,23 @@
class interval_bounds
{
public:
+ interval_bounds():_bits(){}
explicit interval_bounds(bound_type bounds): _bits(bounds){}
interval_bounds left ()const { return interval_bounds(_bits & 1); }
interval_bounds right()const { return interval_bounds(_bits & 2); }
interval_bounds both ()const { return interval_bounds(_bits & 3); }
-
+
+ bound_type bits()const{ return _bits; }
+
+ static interval_bounds open() { return interval_bounds(0); } //JODO URG LITERALS
+ static interval_bounds left_open() { return interval_bounds(1); }
+ static interval_bounds right_open(){ return interval_bounds(2); }
+ static interval_bounds closed() { return interval_bounds(3); }
+
public:
bound_type _bits;
};
-inline interval_bounds open_() { return interval_bounds(open_bounded); }
-inline interval_bounds left_open_() { return interval_bounds(left_open); }
-inline interval_bounds right_open_(){ return interval_bounds(right_open); }
-inline interval_bounds closed_() { return interval_bounds(closed_bounded);}
inline interval_bounds left(interval_bounds x1)
{ return interval_bounds(x1._bits & 1); }
@@ -91,7 +96,44 @@
inline interval_bounds right_subtract_bounds(interval_bounds x1, interval_bounds x2)
{ return left(x1) | ~(left(x2) >> 1); }
+inline bool is_complementary(interval_bounds x1)
+{ return x1 == interval_bounds::right_open() || x1 == interval_bounds::left_open(); }
+template<class IntervalT>
+inline typename
+boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type
+outer_bounds(const IntervalT& x1, const IntervalT& x2)
+{ return outer_bounds(x1.bounds(), x2.bounds()); }
+
+template<class IntervalT>
+inline typename
+boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type
+inner_bounds(const IntervalT& x1, const IntervalT& x2)
+{ return inner_bounds(x1.bounds(), x2.bounds()); }
+
+template<class IntervalT>
+inline typename
+boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type
+left_bounds(const IntervalT& x1, const IntervalT& x2)
+{ return left_bounds(x1.bounds(), x2.bounds()); }
+
+template<class IntervalT>
+inline typename
+boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type
+right_bounds(const IntervalT& x1, const IntervalT& x2)
+{ return right_bounds(x1.bounds(), x2.bounds()); }
+
+template<class IntervalT>
+inline typename
+boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type
+left_subtract_bounds(const IntervalT& x1, const IntervalT& x2)
+{ return left_subtract_bounds(x1.bounds(), x2.bounds()); }
+
+template<class IntervalT>
+inline typename
+boost::enable_if<has_dynamic_bounds<IntervalT>, interval_bounds>::type
+right_subtract_bounds(const IntervalT& x1, const IntervalT& x2)
+{ return right_subtract_bounds(x1.bounds(), x2.bounds()); }
}} // namespace itl boost
Modified: sandbox/itl/boost/itl/interval_functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_functions.hpp (original)
+++ sandbox/itl/boost/itl/interval_functions.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -50,9 +50,12 @@
const typename IntervalT::domain_type& up,
itl::bound_type bounds)
{
- return IntervalT(low, up, bounds);
+ return IntervalT(low, up, interval_bounds(bounds));
}
+//==============================================================================
+//= Containedness
+//==============================================================================
//- is_empty -------------------------------------------------------------------
/** Is the interval empty? */
template<class IntervalT>
@@ -80,24 +83,47 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
is_empty(const IntervalT& object)
{
- if(is_closed(object))
+ if(object.bounds() == interval_bounds::closed())
return IntervalT::domain_less(object.lower(), object.upper());
else
return IntervalT::domain_less_equal(object.lower(), object.upper());
}
+//- contains -------------------------------------------------------------------
+template<class IntervalT>
+typename boost::enable_if<is_interval<IntervalT>, bool>::type
+contains(const IntervalT& super, const IntervalT& sub)
+{
+ return lower_less_equal(super,sub) && upper_less_equal(sub,super);
+}
+
+template<class IntervalT>
+typename boost::enable_if<is_interval<IntervalT>, bool>::type
+contains(const IntervalT& super, const typename IntervalT::domain_type& element)
+{
+ return contains(super,IntervalT(element));
+}
+
+//- within ---------------------------------------------------------------------
+template<class IntervalT>
+typename boost::enable_if<is_interval<IntervalT>, bool>::type
+within(const IntervalT& sub, const IntervalT& super)
+{
+ return contains(super,sub);
+}
+
+
+
//==============================================================================
-//= Selection
+//= Properties
//==============================================================================
-/*JODO
template<class IntervalT>
-typename boost::enable_if<!is_continuous<typename IntervalT::domain_type>,
- typename IntervalT::domain_type>::type
-first(const IntervalT& object)
-{
+typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
+is_closed(const IntervalT& object)
+{
+ is_closed(object.bounds());
}
-*/
//==============================================================================
//= Equivalences and Orderings
@@ -131,7 +157,7 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
exclusive_less(const IntervalT& left, const IntervalT& right)
{
- if(inner_bounds(left,right).is_closed())
+ if(inner_bounds(left,right) == interval_bounds::closed())
return IntervalT::domain_less(left.lower(), right.upper());
else
return IntervalT::domain_less_equal(left.lower(), right.upper());
@@ -163,7 +189,7 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
lower_less(const IntervalT& left, const IntervalT& right)
{
- if(left_bounds(left,right).is_right_open()) //'[(' == 10
+ if(left_bounds(left,right) == interval_bounds::right_open()) //'[(' == 10
return IntervalT::domain_less_equal(left.lower(), right.lower());
else
return IntervalT::domain_less(left.lower(), right.lower());
@@ -196,7 +222,7 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
upper_less(const IntervalT& left, const IntervalT& right)
{
- if(right_bounds(left,right).is_left_open())
+ if(right_bounds(left,right) == interval_bounds::left_open())
return IntervalT::domain_less_equal(left.upper(), right.upper());
else
return IntervalT::domain_less(left.upper(), right.upper());
@@ -265,7 +291,7 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
lower_equal(const IntervalT& left, const IntervalT& right)
{
- return (left_bound(left)==left_bound(right))
+ return (left.bounds().left()==right.bounds().left())
&& IntervalT::domain_equal(left.lower(), right.lower());
}
@@ -296,10 +322,25 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
upper_equal(const IntervalT& left, const IntervalT& right)
{
- return (right_bound(left)==right_bound(right))
+ return (left.bounds().right()==right.bounds().right())
&& IntervalT::domain_equal(left.upper(), right.upper());
}
+//------------------------------------------------------------------------------
+template<class IntervalT>
+typename boost::enable_if<is_interval<IntervalT>, bool>::type
+lower_less_equal(const IntervalT& left, const IntervalT& right)
+{
+ return lower_less(left,right) || lower_equal(left,right);
+}
+
+template<class IntervalT>
+typename boost::enable_if<is_interval<IntervalT>, bool>::type
+upper_less_equal(const IntervalT& left, const IntervalT& right)
+{
+ return upper_less(left,right) || upper_equal(left,right);
+}
+
//- operator == ----------------------------------------------------------------
template<class IntervalT>
@@ -350,11 +391,38 @@
typename boost::enable_if<is_continuous_interval<IntervalT>, bool>::type
touches(const IntervalT& left, const IntervalT& right)
{
- return inner_bounds(left,right).are_complementary()
+ return is_complementary(inner_bounds(left,right))
&& IntervalT::domain_equal(left.upper(), right.lower());
}
+//==============================================================================
+//= Size
+//==============================================================================
+//- cardinality ----------------------------------------------------------------
+template<class IntervalT>
+typename boost::enable_if<is_continuous_interval<IntervalT>,
+ typename IntervalT::size_type>::type
+cardinality(IntervalT object)
+{
+ typedef typename IntervalT::size_type SizeT;
+ if(itl::is_empty(object))
+ return itl::neutron<SizeT>::value();
+ else if( object.bounds() == interval_bounds::closed()
+ && IntervalT::domain_equal(object.lower(), object.upper()))
+ return itl::unon<SizeT>::value();
+ else
+ return infinity<SizeT>::value();
+}
+
+//- size -----------------------------------------------------------------------
+template<class IntervalT>
+typename boost::enable_if<is_continuous_interval<IntervalT>,
+ typename IntervalT::size_type>::type
+size(IntervalT object) //JODO conficting with metafunction size<T>::type -> sizetype<T>::type
+{
+ return cardinality(object);
+}
//==============================================================================
//= Addition
@@ -395,11 +463,11 @@
else if(itl::is_empty(left))
return right;
- return construct
+ return construct<IntervalT>
(
lower_min(left, right),
upper_max(left, right),
- outer_bounds(left, right)
+ outer_bounds(left, right).bits()
);
}
@@ -440,8 +508,8 @@
//JODO
if(exclusive_less(left_minuend, right))
return right;
- return construct(left_minuend.upper(), right.upper(),
- left_subtract_bounds(right, left_minuend));
+ return construct<IntervalT>(left_minuend.upper(), right.upper(),
+ left_subtract_bounds(right, left_minuend).bits());
}
@@ -479,8 +547,8 @@
//JODO s.o.
if(exclusive_less(left, right_minuend))
return left;
- return construct(left.lower(), right_minuend.lower(),
- right_subtract_bounds(left, right) );
+ return construct<IntervalT>(left.lower(), right_minuend.lower(),
+ right_subtract_bounds(left,right_minuend).bits());
}
//==============================================================================
@@ -541,6 +609,8 @@
//------------------------------------------------------------------------------
+
+
}} // namespace itl boost
#endif
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -23,7 +23,7 @@
template<class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
- template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
class split_interval_map;
/** \brief implements a map as a map of intervals - on insertion
@@ -36,7 +36,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
- template<class,ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class interval_map:
@@ -53,7 +53,7 @@
typedef interval_base_map<type,
DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::value_type value_type;
typedef typename base_type::element_type element_type;
@@ -179,7 +179,7 @@
} ;
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::joinable(const iterator& some, const iterator& next)const
{
@@ -190,7 +190,7 @@
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join_on_left(iterator& left_, const iterator& right_)
@@ -206,7 +206,7 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join_on_right(const iterator& left_, iterator& right_)
@@ -224,7 +224,7 @@
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join_left(iterator& it_)
@@ -241,7 +241,7 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join_right(iterator& it_)
@@ -262,7 +262,7 @@
//-----------------------------------------------------------------------------
// add<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_(const value_type& addend)
@@ -297,7 +297,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
@@ -334,7 +334,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_front(const interval_type& inter_val, iterator& first_)
{
@@ -360,7 +360,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_main(interval_type& x_rest, const CodomainT& co_val, iterator& it_, const iterator& last_)
@@ -376,7 +376,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_segment(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
@@ -406,7 +406,7 @@
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
@@ -491,7 +491,7 @@
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_(const value_type& minuend)
@@ -521,7 +521,7 @@
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_front(const interval_type& inter_val, const CodomainT&, iterator& it_)
{
@@ -536,7 +536,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_main(const CodomainT& co_val, iterator& it_, iterator& last_)
@@ -556,7 +556,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
@@ -595,7 +595,7 @@
// insert(pair(interval,value)):
//-----------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_(const value_type& addend)
{
@@ -623,7 +623,7 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_(iterator prior_, const value_type& addend)
@@ -654,7 +654,7 @@
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_range(const interval_type& inter_val, const CodomainT& co_val, iterator& it_, iterator& last_)
{
@@ -699,7 +699,7 @@
//-----------------------------------------------------------------------------
// erase(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_(const value_type& minuend)
{
@@ -758,7 +758,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_rest(const interval_type& inter_val, const CodomainT& co_val,
iterator& it_, iterator& last_)
@@ -784,21 +784,21 @@
//-----------------------------------------------------------------------------
// type traits
//-----------------------------------------------------------------------------
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
@@ -806,21 +806,21 @@
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
@@ -830,7 +830,7 @@
//-----------------------------------------------------------------------------
// type representation
//-----------------------------------------------------------------------------
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct type_to_string<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
static std::string apply()
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -22,7 +22,7 @@
<
typename DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- template<class,ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class interval_set:
@@ -48,7 +48,7 @@
/// The element type of the set
typedef DomainT element_type;
/// The interval type of the set
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
/// The segment type of the set
typedef interval_type segment_type;
@@ -158,7 +158,7 @@
} ;
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_set<DomainT,Compare,Interval,Alloc>::iterator
interval_set<DomainT,Compare,Interval,Alloc>::handle_neighbours(iterator it_)
{
@@ -206,7 +206,7 @@
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename interval_set<DomainT,Compare,Interval,Alloc>::iterator
interval_set<DomainT,Compare,Interval,Alloc>
::join_on_left(iterator& left_, const iterator& right_)
@@ -223,7 +223,7 @@
}
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& addend)
{
if(itl::is_empty(addend)) return;
@@ -250,7 +250,7 @@
}
}
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
typename interval_set<DomainT,Compare,Interval,Alloc>::iterator
interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
{
@@ -281,7 +281,7 @@
}
}
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& minuend)
{
if(itl::is_empty(minuend)) return;
@@ -308,7 +308,7 @@
//-----------------------------------------------------------------------------
// equality of elements
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool is_element_equal(const interval_set<DomainT,Compare,Interval,Alloc>& lhs,
const interval_set<DomainT,Compare,Interval,Alloc>& rhs)
{
@@ -319,14 +319,14 @@
//-----------------------------------------------------------------------------
// type traits
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
@@ -337,7 +337,7 @@
//-----------------------------------------------------------------------------
// type representation
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct type_to_string<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
static std::string apply()
Modified: sandbox/itl/boost/itl/ptime.hpp
==============================================================================
--- sandbox/itl/boost/itl/ptime.hpp (original)
+++ sandbox/itl/boost/itl/ptime.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -32,8 +32,8 @@
#endif
#include <boost/itl/type_traits/neutron.hpp>
-#include <boost/itl/type_traits/difference.hpp>
-#include <boost/itl/type_traits/size.hpp>
+#include <boost/itl/type_traits/difference_type_of.hpp>
+#include <boost/itl/type_traits/size_type_of.hpp>
namespace boost{namespace itl
{
@@ -44,11 +44,11 @@
}
template<>
- struct difference<boost::posix_time::ptime>
+ struct difference_type_of<boost::posix_time::ptime>
{ typedef boost::posix_time::time_duration type; };
template<>
- struct size<boost::posix_time::ptime>
+ struct size_type_of<boost::posix_time::ptime>
{ typedef boost::posix_time::time_duration type; };
// ------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -20,7 +20,7 @@
<
typename DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- template<class,ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class separate_interval_set:
@@ -44,7 +44,7 @@
/// The element type of the set
typedef DomainT element_type;
/// The interval type of the set
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
/// The segment type of the set
typedef interval_type segment_type;
@@ -143,7 +143,7 @@
} ;
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void separate_interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& addend)
{
if(itl::is_empty(addend)) return;
@@ -170,7 +170,7 @@
}
}
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
typename separate_interval_set<DomainT,Compare,Interval,Alloc>::iterator
separate_interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
{
@@ -202,7 +202,7 @@
}
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void separate_interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& minuend)
{
if(itl::is_empty(minuend)) return;
@@ -229,21 +229,21 @@
//-----------------------------------------------------------------------------
// type traits
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
@@ -253,7 +253,7 @@
//-----------------------------------------------------------------------------
// type representation
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct type_to_string<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
static std::string apply()
Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -32,7 +32,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
- template<class,ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class split_interval_map:
@@ -50,7 +50,7 @@
typedef DomainT domain_type;
typedef CodomainT codomain_type;
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::value_type value_type;
typedef typename base_type::element_type element_type;
@@ -164,7 +164,7 @@
//-----------------------------------------------------------------------------
// add<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_(const value_type& addend)
@@ -196,7 +196,7 @@
}
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline typename split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
@@ -233,7 +233,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_front(const interval_type& inter_val, iterator& first_)
{
@@ -259,7 +259,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_main(interval_type& x_rest, const CodomainT& co_val, iterator& it_, const iterator& last_)
@@ -275,7 +275,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_segment(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
@@ -297,7 +297,7 @@
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
@@ -371,7 +371,7 @@
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_(const value_type& minuend)
@@ -400,7 +400,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_front(const interval_type& inter_val, iterator& it_)
{
@@ -417,7 +417,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_main(const CodomainT& co_val, iterator& it_, iterator& last_)
@@ -432,7 +432,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
template<class Combiner>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::subtract_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
@@ -462,7 +462,7 @@
// insert(pair(interval,value)):
//-----------------------------------------------------------------------------
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_(const value_type& addend)
{
@@ -488,7 +488,7 @@
}
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_(iterator prior_, const value_type& addend)
@@ -519,7 +519,7 @@
template <typename DomainT, typename CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::insert_range(const interval_type& inter_val, const CodomainT& co_val, iterator& it_, iterator& last_)
{
@@ -557,7 +557,7 @@
//-----------------------------------------------------------------------------
// erase(pair(interval,value)):
//-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_(const value_type& minuend)
{
@@ -616,7 +616,7 @@
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase_rest(const interval_type& inter_val, const CodomainT& co_val,
iterator& it_, iterator& last_)
@@ -643,49 +643,49 @@
// type traits
//-----------------------------------------------------------------------------
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
@@ -693,7 +693,7 @@
};
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct type_to_string<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
static std::string apply()
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -21,7 +21,7 @@
<
typename DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- template<class,ITL_COMPARE>class Interval = ITL_INTERVAL_DEFAULT,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class split_interval_set:
@@ -43,7 +43,7 @@
/// The element type of the set
typedef DomainT element_type;
/// The interval type of the set
- typedef Interval<DomainT,Compare> interval_type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
/// The segment type of the set
typedef interval_type segment_type;
@@ -144,7 +144,7 @@
} ;
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_set<DomainT,Compare,Interval,Alloc>::add_(const value_type& addend)
{
if(itl::is_empty(addend)) return;
@@ -167,7 +167,7 @@
}
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline typename split_interval_set<DomainT,Compare,Interval,Alloc>::iterator
split_interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
{
@@ -197,7 +197,7 @@
}
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_set<DomainT,Compare,Interval,Alloc>
::add_front(const interval_type& inter_val, iterator& first_)
{
@@ -223,7 +223,7 @@
}
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_set<DomainT,Compare,Interval,Alloc>
::add_main(interval_type& x_rest, iterator& it_, const iterator& last_)
{
@@ -238,7 +238,7 @@
}
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_set<DomainT,Compare,Interval,Alloc>
::add_segment(const interval_type& inter_val, iterator& it_)
{
@@ -254,7 +254,7 @@
}
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_set<DomainT,Compare,Interval,Alloc>
::add_rear(const interval_type& inter_val, iterator& it_)
{
@@ -288,7 +288,7 @@
}
-template<class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline void split_interval_set<DomainT,Compare,Interval,Alloc>::subtract_(const value_type& minuend)
{
if(itl::is_empty(minuend)) return;
@@ -321,7 +321,7 @@
NOTE: This is not inline with the mathematical view.
We have a distinction between 'element equality' and 'lexicographical
equality'. */
-template <typename DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <typename DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
inline bool operator == (const split_interval_set<DomainT,Compare,Interval,Alloc>& lhs,
const split_interval_set<DomainT,Compare,Interval,Alloc>& rhs)
{
@@ -331,21 +331,21 @@
//-----------------------------------------------------------------------------
// type traits
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
typedef is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
@@ -355,7 +355,7 @@
//-----------------------------------------------------------------------------
// type representation
//-----------------------------------------------------------------------------
-template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
struct type_to_string<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
static std::string apply()
Added: sandbox/itl/boost/itl/type_traits/difference_type_of.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/difference_type_of.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,19 @@
+/*-----------------------------------------------------------------------------+
+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_DIFFERENCE_TYPE_OF_HPP_JOFA_080911
+#define BOOST_ITL_TYPE_TRAITS_DIFFERENCE_TYPE_OF_HPP_JOFA_080911
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct difference_type_of{ typedef Type type; };
+
+}} // namespace boost itl
+
+#endif
+
+
Added: sandbox/itl/boost/itl/type_traits/size_type_of.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/size_type_of.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,18 @@
+/*-----------------------------------------------------------------------------+
+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_SIZE_TYPE_OF_HPP_JOFA_080911
+#define BOOST_ITL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct size_type_of{ typedef std::size_t type; };
+}} // namespace boost itl
+
+#endif
+
+
Modified: sandbox/itl/boost/validate/driver/itl_set_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_set_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_set_driver.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -93,7 +93,7 @@
algebra_validater* chooseValidater()
{
- typedef int intT;
+ typedef double intT; //JODO REV
typedef double doubleT;
int rootChoice = _rootChoice.some();
Modified: sandbox/itl/libs/itl/doc/acknowledgments.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/acknowledgments.qbk (original)
+++ sandbox/itl/libs/itl/doc/acknowledgments.qbk 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -33,7 +33,7 @@
I am grateful to Hartmut Kaiser for managing the formal review of
this library and to all the reviewers and participants
in the related discussions, including Jeff Flinn, Luke Simonson,
-Phil Endecott, Eric M. Jonas, Peter Wuttke, Robert Stuard,
+Phil Endecott, Eric M. Jonas, Peter Wuttke, Robert Stewart,
Barend Gehrels, Vicente Botet, Thomas Klimpel, Paul A. Bristow,
Jerry Jeremiah, John Reid, Steven Watanabe, Brian Wood, Markus Werle
and Michael Caisse.
Modified: sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -40,7 +40,7 @@
typename DomainT = nat64,
typename BitSetT = bits64,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- template<class, ITL_COMPARE>class Interval = boost::itl::interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
class large_bitset
@@ -59,11 +59,11 @@
, boost::andable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, DomainT
, boost::xorable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, DomainT
- , boost::addable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, Interval<DomainT,Compare>
- , boost::orable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, Interval<DomainT,Compare>
- , boost::subtractable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, Interval<DomainT,Compare>
- , boost::andable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, Interval<DomainT,Compare>
- , boost::xorable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, Interval<DomainT,Compare>
+ , boost::addable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, ITL_INTERVAL_TYPE(Interval,DomainT,Compare)
+ , boost::orable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, ITL_INTERVAL_TYPE(Interval,DomainT,Compare)
+ , boost::subtractable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, ITL_INTERVAL_TYPE(Interval,DomainT,Compare)
+ , boost::andable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, ITL_INTERVAL_TYPE(Interval,DomainT,Compare)
+ , boost::xorable2 < large_bitset<DomainT,BitSetT,Compare,Interval,Alloc>, ITL_INTERVAL_TYPE(Interval,DomainT,Compare)
> > > > > > > > > > > > > > > > >
//^ & - | + ^ & - | + ^ & - | + < ==
//segment element container
Modified: sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -72,7 +72,8 @@
(fastest_itl_interval_subtract_4_bicremental_types)
{ interval_subtract_4_bicremental_types<bicremental_type_5>(); }
+/*JODO
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_inner_complement_4_bicremental_types)
{ interval_inner_complement_4_bicremental_types<bicremental_type_6>(); }
-
+*/
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -81,12 +81,20 @@
}
*/
-#include <boost/itl/rightopen_interval.hpp>
-#include <boost/itl/type_traits/is_asymmetric_interval.hpp>
+#include <boost/itl/continuous_interval.hpp>
+#include <boost/itl/type_traits/is_continuous_interval.hpp>
+
+
+BOOST_AUTO_TEST_CASE(interval_type_traits)
+{
+ BOOST_CHECK_EQUAL(is_interval<continuous_interval<int> >::value, true);
+ BOOST_CHECK_EQUAL(is_continuous_interval<continuous_interval<int> >::value, false);
+ BOOST_CHECK_EQUAL(is_continuous_interval<continuous_interval<double> >::value, true);
+}
BOOST_AUTO_TEST_CASE(casual)
{
- BOOST_CHECK_EQUAL(is_interval<rightopen_interval<int> >::value, true);
- BOOST_CHECK_EQUAL(is_asymmetric_interval<rightopen_interval<int> >::value, true);
+ continuous_interval<double> conterval;
+ BOOST_CHECK_EQUAL(itl::is_empty(conterval), true);
}
Added: sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,34 @@
+/*-----------------------------------------------------------------------------+
+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)
++-----------------------------------------------------------------------------*/
+#define BOOST_TEST_MODULE itl::interval unit test
+#include <string>
+#include <boost/mpl/list.hpp>
+#include "../unit_test_unwarned.hpp"
+#include <boost/test/test_case_template.hpp>
+
+// interval instance types
+#include "../test_type_lists.hpp"
+#include "../test_value_maker.hpp"
+
+#include <boost/itl/continuous_interval.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace unit_test;
+using namespace boost::itl;
+
+
+#include "../test_itl_interval_shared.hpp"
+//CL #include "../test_itl_interval.hpp"
+
+#define ORDERED_TYPES continuous_types
+#define BICREMENTAL_TYPES bicremental_continuous_types
+
+#define INTERVAL continuous_interval
+#include "../test_interval_cases.hpp" //Common cases for different interval types
+
Added: sandbox/itl/libs/itl/test/test_continuous_interval_/vc9_test_continuous_interval.vcproj
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/test/test_continuous_interval_/vc9_test_continuous_interval.vcproj 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="9,00"
+ Name="vc9_test_continuous_interval"
+ ProjectGUID="{EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}"
+ RootNamespace="Test_continuous_interval"
+ Keyword="Win32Proj"
+ TargetFrameworkVersion="131072"
+ >
+ <Platforms>
+ <Platform
+ Name="Win32"
+ />
+ </Platforms>
+ <ToolFiles>
+ </ToolFiles>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../../../bin/debug/"
+ IntermediateDirectory="../../../../bin/obj/$(ProjectName)/debug/"
+ ConfigurationType="1"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../../; ../../../../boost_1_35_0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="false"
+ DebugInformationFormat="4"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ OutputFile="../../../../bin/debug/$(ProjectName).exe"
+ LinkIncremental="2"
+ AdditionalLibraryDirectories="../../../../lib; ../../../../stage/lib"
+ GenerateDebugInformation="true"
+ SubSystem="1"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../../../bin/release/"
+ IntermediateDirectory="../../../../bin/obj/$(ProjectName)/release/"
+ ConfigurationType="1"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalIncludeDirectories="../../../../; ../../../../boost_1_35_0"
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="4"
+ Detect64BitPortabilityProblems="false"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ OutputFile="../../../../bin/release/$(ProjectName).exe"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../lib; ../../../../stage/lib"
+ GenerateDebugInformation="true"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+ >
+ <File
+ RelativePath=".\test_continuous_interval.cpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+ >
+ </Filter>
+ <Filter
+ Name="Resource Files"
+ Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+ >
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -22,10 +22,10 @@
template <class T, class U, class Trt,
template<class T, class U,
class Traits = Trt,
- ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class SequenceT
@@ -44,7 +44,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class SequenceT
Added: sandbox/itl/libs/itl/test/test_interval_cases.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/test/test_interval_cases.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,19 @@
+/*-----------------------------------------------------------------------------+
+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 __test_IntervalT_hpp_JOFA_100401__
+#define __test_IntervalT_hpp_JOFA_100401__
+
+BOOST_AUTO_TEST_CASE_TEMPLATE
+(test_itl_interval_ctor_4_ordered_types, T, ORDERED_TYPES)
+{ interval_ctor_4_ordered_types<T, std::less, INTERVAL>();}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE
+(test_itl_interval_ctor_4_bicremental_types, T, BICREMENTAL_TYPES)
+{ interval_ctor_4_bicremental_types<T, std::less, INTERVAL>();}
+
+#endif // __test_IntervalT_hpp_JOFA_100401__
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -13,7 +13,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -162,7 +162,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -225,7 +225,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -278,7 +278,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -311,7 +311,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -363,7 +363,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -416,7 +416,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -458,7 +458,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -498,7 +498,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -540,7 +540,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -646,7 +646,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -763,7 +763,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -847,7 +847,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -873,7 +873,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -900,7 +900,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -929,7 +929,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -981,7 +981,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -1030,7 +1030,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -1069,7 +1069,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -1101,7 +1101,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
class T, class U>
@@ -1128,7 +1128,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -1199,7 +1199,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -1240,7 +1240,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
Modified: sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -18,7 +18,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -45,7 +45,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -75,7 +75,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -102,7 +102,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -132,7 +132,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -161,7 +161,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -194,7 +194,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -223,7 +223,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
Modified: sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -15,7 +15,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -39,7 +39,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -66,7 +66,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -90,7 +90,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -117,7 +117,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -143,7 +143,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -173,7 +173,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -199,7 +199,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -11,7 +11,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -142,7 +142,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -193,7 +193,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -234,7 +234,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -261,7 +261,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -300,7 +300,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -345,7 +345,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -390,7 +390,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -429,7 +429,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -473,7 +473,7 @@
// Test for nontrivial intersection of interval sets with intervals and values
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -546,7 +546,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -585,7 +585,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -607,7 +607,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -630,7 +630,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -652,7 +652,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -675,7 +675,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -698,7 +698,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -721,7 +721,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
Modified: sandbox/itl/libs/itl/test/test_itl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -13,8 +13,8 @@
{
// An empty interval is defined as the closed interval [1,0]
BOOST_CHECK_EQUAL(interval<T>().empty(), true);
- BOOST_CHECK_EQUAL(interval<T>().cardinality(), itl::neutron<typename itl::size<T>::type>::value());
- BOOST_CHECK_EQUAL(interval<T>().size(), itl::neutron<typename itl::size<T>::type>::value());
+ BOOST_CHECK_EQUAL(interval<T>().cardinality(), itl::neutron<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(interval<T>().size(), itl::neutron<typename itl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL(interval<T>().lower(), itl::unon<T>::value());
BOOST_CHECK_EQUAL(interval<T>().upper(), itl::neutron<T>::value());
@@ -29,7 +29,7 @@
BOOST_CHECK_EQUAL( T(), pred(succ(T())));
BOOST_CHECK_EQUAL( itl::neutron<T>::value(), pred(succ(itl::neutron<T>::value())) );
BOOST_CHECK_EQUAL( itl::unon<T>::value(), succ(itl::neutron<T>::value()) );
- BOOST_CHECK_EQUAL( interval<T>().length(), itl::neutron<typename difference<T>::type>::value() );
+ BOOST_CHECK_EQUAL( interval<T>().length(), itl::neutron<typename difference_type_of<T>::type>::value() );
T v4 = make<T>(4);
itl::interval<T> I4_4I(v4);
@@ -106,7 +106,7 @@
BOOST_CHECK_EQUAL(interval<T>(0,0).length(), itl::unon<typename interval<T>::difference_type>::value());
}
-void interval_ctor_specific()
+void interval_ctor_specific()//JODO
{
BOOST_CHECK_EQUAL(interval<double>().length(), 0.0);
BOOST_CHECK_EQUAL(interval<double>(5.0,5.0).cardinality(), 1);
@@ -408,16 +408,17 @@
BOOST_CHECK_EQUAL( diff_2, I4_7D );
}
+/*JODO
template <class T>
void interval_inner_complement_4_bicremental_types()
{
- test_inner_complement(interval<T>(), interval<T>());
+ test_inner_complement(interval<T>(), interval<T>());
test_inner_complement(interval<T>(), I_D(6,9));
test_inner_complement(C_D(2,4), interval<T>());
test_inner_complement(I_I(2,5), C_I(3,9));
test_inner_complement(I_I(2,4), I_D(6,9));
test_inner_complement(I_D(7,9), C_I(0,3));
}
-
+*/
#endif // __test_itl_interval_hpp_JOFA_081006__
Modified: sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -74,7 +74,9 @@
(test_itl_interval_subtract_4_bicremental_types, T, bicremental_types)
{ interval_subtract_4_bicremental_types<T>(); }
+/*JODO
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_interval_inner_complement_4_bicremental_types, T, bicremental_types)
{ interval_inner_complement_4_bicremental_types<T>(); }
+*/
Modified: sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -8,17 +8,151 @@
#ifndef __test_itl_interval_shared_hpp_JOFA_100306__
#define __test_itl_interval_shared_hpp_JOFA_100306__
-#include <boost/itl/interval.hpp>
+//CL #include <boost/itl/interval.hpp>
#include <boost/itl/interval_set.hpp>
+template <class T, ITL_COMPARE Compare,
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+void interval_ctor_4_ordered_types()
+{
+ typedef Interval<T,Compare> IntervalT;
+ // An empty interval is defined as the closed interval [1,0]
+ BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
+ BOOST_CHECK_EQUAL(cardinality(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(IntervalT().lower(), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT());
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value(), interval_bounds::right_open()));
+}
+
+
+template <class T, ITL_COMPARE Compare,
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+void interval_ctor_4_bicremental_types()
+{
+ typedef Interval<T,Compare> IntervalT;
+
+ BOOST_CHECK_EQUAL( T(), pred(succ(T())));
+ BOOST_CHECK_EQUAL( itl::neutron<T>::value(), pred(succ(itl::neutron<T>::value())) );
+ BOOST_CHECK_EQUAL( itl::unon<T>::value(), succ(itl::neutron<T>::value()) );
+ BOOST_CHECK_EQUAL( interval<T>().length(), itl::neutron<typename difference_type_of<T>::type>::value() );
+
+ T v4 = make<T>(4);
+ IntervalT I4_4I(v4);
+ BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::closed(), true );
+ BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::left_open(), false );
+ BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::left_open(), false );
+ BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::right_open(), false );
+ BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::open(), false );
+ /*JODO
+ BOOST_CHECK_EQUAL( I4_4I.is_left(closed_bounded), true );
+ BOOST_CHECK_EQUAL( I4_4I.is_right(closed_bounded), true );
+ BOOST_CHECK_EQUAL( I4_4I.is_left(open_bounded), false );
+ BOOST_CHECK_EQUAL( I4_4I.is_right(open_bounded), false );
+ */
+
+ BOOST_CHECK_EQUAL( I4_4I.lower(), v4 );
+ BOOST_CHECK_EQUAL( I4_4I.upper(), v4 );
+
+ BOOST_CHECK_EQUAL( contains(I4_4I, v4), true );
+ BOOST_CHECK_EQUAL( contains(I4_4I, I4_4I), true );
+ BOOST_CHECK_EQUAL( within(I4_4I, I4_4I), true );
+ BOOST_CHECK_EQUAL( I4_4I, I4_4I );
+ BOOST_CHECK_EQUAL( cardinality(I4_4I), unon<typename interval<T>::size_type>::value() );
+ BOOST_CHECK_EQUAL( itl::size(I4_4I), unon<typename interval<T>::size_type>::value() );
+
+ IntervalT j_4_4(I4_4I);
+ BOOST_CHECK_EQUAL( I4_4I, j_4_4 );
+ IntervalT k_4_4;
+ k_4_4 = j_4_4;
+ BOOST_CHECK_EQUAL( I4_4I, k_4_4 );
+
+ /*
+ T v2 = make<T>(2);
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4) );
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4, closed_bounded) );
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4), interval<T>(v2, v4, right_open) );
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4), interval<T>(v2, v4, left_open) );
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4), interval<T>(v2, v4, open_bounded) );
+
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).lower(), v2 );
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).upper(), v4 );
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).boundtype(), closed_bounded );
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).bounds() == interval_bounds::closed_bounded(), true );
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_left(closed_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_right(closed_bounded), true );
+
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).lower(), v2 );
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).upper(), v4 );
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).boundtype(), right_open );
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).bounds() == interval_bounds::right_open(), true );
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_left(closed_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_right(open_bounded), true );
+
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).lower(), v2 );
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).upper(), v4 );
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).boundtype(), left_open );
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).bounds() == interval_bounds::left_open(), true );
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_left(open_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_right(closed_bounded), true );
+
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).lower(), v2 );
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).upper(), v4 );
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).boundtype(), open_bounded );
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).bounds() == interval_bounds::open_bounded(), true );
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).is_left(open_bounded), true );
+ BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).is_right(open_bounded), true );
+ */
+}
+
+/*JODO
+template <class T, ITL_COMPARE Compare,
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+void interval_equal_4_bicremental_continuous_types()
+{
+ T v3 = make<T>(3);
+ T v7 = make<T>(7);
+ BOOST_CHECK_EQUAL(interval<T>(), interval<T>(v7,v3));
+
+ //I: (I)nside = closed bound
+ //O: (O)utside = open bound
+ interval<T> I3_7I = interval<T>::closed(v3,v7);
+ interval<T> I3_7D = interval<T>::rightopen(v3,v7);
+ interval<T> C3_7I = interval<T>::leftopen(v3,v7);
+ interval<T> C3_7D = interval<T>::open(v3,v7);
+
+ BOOST_CHECK_EQUAL( I3_7I , I3_7I );
+ BOOST_CHECK_EQUAL( I3_7I == I3_7D, false );
+ BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
+ BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
+ BOOST_CHECK_EQUAL( I3_7I != I3_7D, true );
+ BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
+ BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
+
+ BOOST_CHECK_EQUAL( I3_7D , I3_7D );
+ BOOST_CHECK_EQUAL( I3_7D == C3_7I, false );
+ BOOST_CHECK_EQUAL( I3_7D == C3_7D, false );
+ BOOST_CHECK_EQUAL( I3_7D != C3_7I, true );
+ BOOST_CHECK_EQUAL( I3_7D != C3_7D, true );
+
+ BOOST_CHECK_EQUAL( C3_7I , C3_7I );
+ BOOST_CHECK_EQUAL( C3_7I == C3_7D, false );
+ BOOST_CHECK_EQUAL( C3_7I != C3_7D, true );
+
+ BOOST_CHECK_EQUAL( C3_7D, C3_7D );
+}
+*/
+
template <class DomainT, ITL_COMPARE Compare,
- template<class,ITL_COMPARE>class Interval>
-void test_inner_complement(const Interval<DomainT,Compare>& itv1,
- const Interval<DomainT,Compare>& itv2)
+ ITL_INTERVAL(ITL_COMPARE) Interval>
+void test_inner_complement(const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& itv1,
+ const ITL_INTERVAL_TYPE(Interval,DomainT,Compare)& itv2)
{
typedef interval_set<DomainT,Compare,Interval> ItvSetT;
- typedef Interval<DomainT,Compare> IntervalT;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) IntervalT;
BOOST_CHECK_EQUAL(itl::length(inner_complement(itv1,itv2)), itl::distance(itv1,itv2));
BOOST_CHECK_EQUAL(itl::length(inner_complement(itv1,itv2)), itl::distance(itv2,itv1));
Modified: sandbox/itl/libs/itl/test/test_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_map.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -15,7 +15,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -48,7 +48,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
Modified: sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -18,7 +18,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -51,7 +51,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -87,7 +87,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -120,7 +120,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -156,7 +156,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -191,7 +191,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -230,7 +230,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -265,7 +265,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
Modified: sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -18,7 +18,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -45,7 +45,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -75,7 +75,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -102,7 +102,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -132,7 +132,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -161,7 +161,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -194,7 +194,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
@@ -223,7 +223,7 @@
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -15,7 +15,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -38,7 +38,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -65,7 +65,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -88,7 +88,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -115,7 +115,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
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-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -15,7 +15,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -45,7 +45,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -78,7 +78,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -107,7 +107,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
@@ -140,7 +140,7 @@
template <class T,
template<class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- template<class,ITL_COMPARE>class Interval = interval,
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalSet
>
Modified: sandbox/itl/libs/itl/test/vc9_slow_tests.sln
==============================================================================
--- sandbox/itl/libs/itl/test/vc9_slow_tests.sln (original)
+++ sandbox/itl/libs/itl/test/vc9_slow_tests.sln 2010-04-03 11:50:48 EDT (Sat, 03 Apr 2010)
@@ -43,6 +43,8 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_total_interval_quantifier", "test_total_interval_quantifier_\vc9_test_total_interval_quantifier.vcproj", "{EE61B7EF-EC45-4165-8B4B-FD5B7D2A9F9F}"
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_continuous_interval", "test_continuous_interval_\vc9_test_continuous_interval.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
@@ -133,6 +135,10 @@
{EE61B7EF-EC45-4165-8B4B-FD5B7D2A9F9F}.Debug|Win32.Build.0 = Debug|Win32
{EE61B7EF-EC45-4165-8B4B-FD5B7D2A9F9F}.Release|Win32.ActiveCfg = Release|Win32
{EE61B7EF-EC45-4165-8B4B-FD5B7D2A9F9F}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
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