|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r79683 - in sandbox/icl/boost/icl: . concept detail type_traits
From: afojgo_at_[hidden]
Date: 2012-07-22 18:16:55
Author: jofaber
Date: 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
New Revision: 79683
URL: http://svn.boost.org/trac/boost/changeset/79683
Log:
Merged revision(s) 71362-79210 from trunk/boost/icl:
Added macro BOOST_ICL_USE_COMPARE_STD_GREATER to change container and interval orderings for the library.
This can be used to change the compare-ordering for whole test-programs. (ticket #5482).
........
Patch sent by Christoffer Jefferson, 04-22-2001.
The following patch does two things:
1) Cleans up a bunch of warnings to do with "unused parameter", which I get in clang.
2) Add a couple of headers which clang needs.
........
Bug fix for ticket 5559: Assertion for numeric_minimum failed for std::greater ordering.
Added a Compare-parameter and a partial specialization for struct template numeric_minimum.
........
Bug fix for ticket 5559: Assertion for numeric_minimum failed for std::greater ordering. Adjustments for portability.
........
Bug fix for ticket 5559: Assertion for numeric_minimum failed for std::greater ordering. Adjustments for portability 2.
........
Fixed ticket #5562: typo in boost\icl\concept\element_set.hpp
........
Cleaning up tests after checking last bug claims by Denis.
........
eliminated test_case_template.hpp
........
Fixed ticket #6095 filed by Marvin Sielenkemper. https://svn.boost.org/trac/boost/ticket/6095. Completing is_empty for open intervals (numeric_limits<domain_type>::max(), x).
........
Resolving ambiguity in call of identity_element.
........
Polished ticket #6095 filed by Marvin Sielenkemper. https://svn.boost.org/trac/boost/ticket/6095. Improved implementation of is_empty for open intervals as suggested by Marvin.
........
Replaced TABs by BLANKs. Bug fix ticket #6095 complete.
........
Bugfix ticket 6210. In addition: Some changes for introducing move semantics.
........
Added move emulation.
........
Fixed a configuration error.
........
Generated tests (prefixed by bcont_) for an implementation variant using Boost.Container.
........
Fixed bug in move constructor.
........
Portability fix for gcc.
........
Workaround for gcc static_cast complaints in move emulation tests.
........
Replaced move emulation by c++11. Now using c++11 move ctors and assignment operators.
........
Adding vc10 convenience project files
........
Adding vc10 convenience project files
........
Added move semantics for T operators(...) according to the Dave-Abrahams-Transformation
(http://cpp-next.com/archive/2009/09/making-your-next-move/). Worked like a charm ;)
........
Fixing missing reference to boost::move.
........
Fixed multiple definition error reported by Rajalakshmi Iyer.
........
Fix for ticket #6924: Now using insert with hint.
........
Fixed ticket #6924 (reporter: John Reid). Improvements of icl/functors.hpp.
........
Properties modified:
sandbox/icl/boost/icl/ (props changed)
Text files modified:
sandbox/icl/boost/icl/associative_interval_container.hpp | 1
sandbox/icl/boost/icl/closed_interval.hpp | 3
sandbox/icl/boost/icl/concept/element_set.hpp | 2
sandbox/icl/boost/icl/concept/interval.hpp | 100 +++++++-----
sandbox/icl/boost/icl/concept/interval_associator.hpp | 319 +++++++++++++++++++++++++++++++++++++++
sandbox/icl/boost/icl/concept/interval_bounds.hpp | 6
sandbox/icl/boost/icl/concept/interval_map.hpp | 2
sandbox/icl/boost/icl/continuous_interval.hpp | 3
sandbox/icl/boost/icl/detail/interval_map_algo.hpp | 10
sandbox/icl/boost/icl/discrete_interval.hpp | 3
sandbox/icl/boost/icl/functors.hpp | 49 ++---
sandbox/icl/boost/icl/gregorian.hpp | 8
sandbox/icl/boost/icl/impl_config.hpp | 45 ++--
sandbox/icl/boost/icl/interval_base_map.hpp | 29 +++
sandbox/icl/boost/icl/interval_base_set.hpp | 42 ++++-
sandbox/icl/boost/icl/interval_map.hpp | 27 +++
sandbox/icl/boost/icl/interval_set.hpp | 20 ++
sandbox/icl/boost/icl/left_open_interval.hpp | 5
sandbox/icl/boost/icl/map.hpp | 59 +++++-
sandbox/icl/boost/icl/open_interval.hpp | 6
sandbox/icl/boost/icl/ptime.hpp | 8
sandbox/icl/boost/icl/right_open_interval.hpp | 2
sandbox/icl/boost/icl/separate_interval_set.hpp | 19 ++
sandbox/icl/boost/icl/set.hpp | 12
sandbox/icl/boost/icl/split_interval_map.hpp | 25 ++
sandbox/icl/boost/icl/split_interval_set.hpp | 19 ++
sandbox/icl/boost/icl/type_traits/infinity.hpp | 2
sandbox/icl/boost/icl/type_traits/is_discrete.hpp | 1
sandbox/icl/boost/icl/type_traits/is_numeric.hpp | 21 +
29 files changed, 685 insertions(+), 163 deletions(-)
Modified: sandbox/icl/boost/icl/associative_interval_container.hpp
==============================================================================
--- sandbox/icl/boost/icl/associative_interval_container.hpp (original)
+++ sandbox/icl/boost/icl/associative_interval_container.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -8,6 +8,7 @@
#ifndef BOOST_ICL_ASSOCIATIVE_INTERVAL_CONTAINER_HPP_JOFA_101023
#define BOOST_ICL_ASSOCIATIVE_INTERVAL_CONTAINER_HPP_JOFA_101023
+#include <boost/icl/impl_config.hpp>
#include <boost/icl/concept/comparable.hpp>
#include <boost/icl/concept/joinable.hpp>
#include <boost/icl/concept/container.hpp>
Modified: sandbox/icl/boost/icl/closed_interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/closed_interval.hpp (original)
+++ sandbox/icl/boost/icl/closed_interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -22,6 +22,7 @@
public:
typedef closed_interval<DomainT,Compare> type;
typedef DomainT domain_type;
+ typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
public:
//==========================================================================
@@ -106,7 +107,7 @@
template<class DomainT>
struct value_size<icl::closed_interval<DomainT> >
{
- static std::size_t apply(const icl::closed_interval<DomainT>& value)
+ static std::size_t apply(const icl::closed_interval<DomainT>&)
{ return 2; }
};
Modified: sandbox/icl/boost/icl/concept/element_set.hpp
==============================================================================
--- sandbox/icl/boost/icl/concept/element_set.hpp (original)
+++ sandbox/icl/boost/icl/concept/element_set.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -93,7 +93,7 @@
template<class Type>
inline typename enable_if<is_element_set<Type>, Type>::type&
-operator ^= (Type& object, const typename Type::element_tpye& operand)
+operator ^= (Type& object, const typename Type::element_type& operand)
{
return icl::flip(object, operand);
}
Modified: sandbox/icl/boost/icl/concept/interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/concept/interval.hpp (original)
+++ sandbox/icl/boost/icl/concept/interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -107,8 +107,10 @@
singleton(const typename interval_traits<Type>::domain_type& value)
{
//ASSERT: This always creates an interval with exactly one element
- typedef typename interval_traits<Type>::domain_type domain_type;
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value) ));
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(value) ));
return interval_traits<Type>::construct(domain_prior<Type>(value), value);
}
@@ -118,8 +120,10 @@
singleton(const typename interval_traits<Type>::domain_type& value)
{
//ASSERT: This always creates an interval with exactly one element
- typedef typename interval_traits<Type>::domain_type domain_type;
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value)));
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(value)));
return interval_traits<Type>::construct( domain_prior<Type>(value)
, domain_next<Type>(value));
@@ -172,8 +176,10 @@
>::type
unit_trail(const typename interval_traits<Type>::domain_type& value)
{
- typedef typename interval_traits<Type>::domain_type domain_type;
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value) ));
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(value) ));
return interval_traits<Type>::construct(domain_prior<Type>(value), value);
}
@@ -187,8 +193,10 @@
>::type
unit_trail(const typename interval_traits<Type>::domain_type& value)
{
- typedef typename interval_traits<Type>::domain_type domain_type;
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value)));
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(value)));
return interval_traits<Type>::construct( domain_prior<Type>(value)
, domain_next<Type>(value));
@@ -279,15 +287,18 @@
hull(const typename interval_traits<Type>::domain_type& left,
const typename interval_traits<Type>::domain_type& right)
{
- typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
if(interval_traits<Type>::domain_compare()(left,right))
{
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(left) ));
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(left) ));
return construct<Type>(domain_prior<Type>(left), right);
}
else
{
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(right) ));
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(right) ));
return construct<Type>(domain_prior<Type>(right), left);
}
}
@@ -308,16 +319,19 @@
hull(const typename interval_traits<Type>::domain_type& left,
const typename interval_traits<Type>::domain_type& right)
{
- typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
if(interval_traits<Type>::domain_compare()(left,right))
{
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(left) ));
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(left) ));
return construct<Type>( domain_prior<Type>(left)
, domain_next<Type>(right));
}
else
{
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(right) ));
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
+ ::is_less_than(right) ));
return construct<Type>( domain_prior<Type>(right)
, domain_next<Type>(left));
}
@@ -402,8 +416,9 @@
, typename interval_traits<Type>::domain_type>::type
last(const Type& object)
{
- typedef typename interval_traits<Type>::domain_type domain_type;
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value>
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
::is_less_than(upper(object)) ));
return domain_prior<Type>(upper(object));
}
@@ -413,8 +428,9 @@
typename interval_traits<Type>::domain_type>::type
last(const Type& object)
{
- typedef typename interval_traits<Type>::domain_type domain_type;
- BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value>
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename interval_traits<Type>::domain_compare domain_compare;
+ BOOST_ASSERT((numeric_minimum<domain_type, domain_compare, is_numeric<domain_type>::value>
::is_less_than_or(upper(object), is_right_closed(object.bounds())) ));
return is_right_closed(object.bounds()) ?
upper(object) :
@@ -531,7 +547,8 @@
typename boost::enable_if<is_static_open<Type>, bool>::type
is_empty(const Type& object)
{
- return domain_less_equal<Type>(upper(object), domain_next<Type>(lower(object)));
+ return domain_less_equal<Type>(upper(object), lower(object) )
+ || domain_less_equal<Type>(upper(object), domain_next<Type>(lower(object)));
}
template<class Type>
@@ -541,7 +558,8 @@
if(object.bounds() == interval_bounds::closed())
return domain_less<Type>(upper(object), lower(object));
else if(object.bounds() == interval_bounds::open())
- return domain_less_equal<Type>(upper(object), domain_next<Type>(lower(object)));
+ return domain_less_equal<Type>(upper(object), lower(object) )
+ || domain_less_equal<Type>(upper(object), domain_next<Type>(lower(object)));
else
return domain_less_equal<Type>(upper(object), lower(object));
}
@@ -591,8 +609,8 @@
exclusive_less(const Type& left, const Type& right)
{
BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
- return domain_less <Type>(left.upper(), right.lower())
- || ( domain_equal<Type>(left.upper(), right.lower())
+ return domain_less <Type>(upper(left), lower(right))
+ || ( domain_equal<Type>(upper(left), lower(right))
&& inner_bounds(left,right) != interval_bounds::open() );
}
@@ -645,12 +663,12 @@
{
return
(is_left_closed(super.bounds())
- ? domain_less_equal<Type>(super.lower(), element)
- : domain_less<Type>(super.lower(), element))
+ ? domain_less_equal<Type>(lower(super), element)
+ : domain_less<Type>(lower(super), element))
&&
(is_right_closed(super.bounds())
- ? domain_less_equal<Type>(element, super.upper())
- : domain_less<Type>(element, super.upper()));
+ ? domain_less_equal<Type>(element, upper(super))
+ : domain_less<Type>(element, upper(super)));
}
//- within ---------------------------------------------------------------------
@@ -698,8 +716,8 @@
exclusive_less(const Type& left, const Type& right)
{
return icl::is_empty(left) || icl::is_empty(right)
- || domain_less<Type>(left.upper(), right.lower())
- || ( domain_equal<Type>(left.upper(), right.lower())
+ || domain_less<Type>(upper(left), lower(right))
+ || ( domain_equal<Type>(upper(left), lower(right))
&& inner_bounds(left,right) != interval_bounds::open() );
}
@@ -709,7 +727,7 @@
typename boost::enable_if<has_static_bounds<Type>, bool>::type
lower_less(const Type& left, const Type& right)
{
- return domain_less<Type>(left.lower(), right.lower());
+ return domain_less<Type>(lower(left), lower(right));
}
template<class Type>
@@ -724,9 +742,9 @@
lower_less(const Type& left, const Type& right)
{
if(left_bounds(left,right) == interval_bounds::right_open()) //'[(' == 10
- return domain_less_equal<Type>(left.lower(), right.lower());
+ return domain_less_equal<Type>(lower(left), lower(right));
else
- return domain_less<Type>(left.lower(), right.lower());
+ return domain_less<Type>(lower(left), lower(right));
}
@@ -735,7 +753,7 @@
typename boost::enable_if<has_static_bounds<Type>, bool>::type
upper_less(const Type& left, const Type& right)
{
- return domain_less<Type>(left.upper(), right.upper());
+ return domain_less<Type>(upper(left), upper(right));
}
template<class Type>
@@ -750,9 +768,9 @@
upper_less(const Type& left, const Type& right)
{
if(right_bounds(left,right) == interval_bounds::left_open())
- return domain_less_equal<Type>(left.upper(), right.upper());
+ return domain_less_equal<Type>(upper(left), upper(right));
else
- return domain_less<Type>(left.upper(), right.upper());
+ return domain_less<Type>(upper(left), upper(right));
}
//------------------------------------------------------------------------------
@@ -797,7 +815,7 @@
typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
lower_equal(const Type& left, const Type& right)
{
- return domain_equal<Type>(left.lower(), right.lower());
+ return domain_equal<Type>(lower(left), lower(right));
}
template<class Type>
@@ -819,7 +837,7 @@
lower_equal(const Type& left, const Type& right)
{
return (left.bounds().left()==right.bounds().left())
- && domain_equal<Type>(left.lower(), right.lower());
+ && domain_equal<Type>(lower(left), lower(right));
}
@@ -828,7 +846,7 @@
typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
upper_equal(const Type& left, const Type& right)
{
- return domain_equal<Type>(left.upper(), right.upper());
+ return domain_equal<Type>(upper(left), upper(right));
}
template<class Type>
@@ -850,7 +868,7 @@
upper_equal(const Type& left, const Type& right)
{
return (left.bounds().right()==right.bounds().right())
- && domain_equal<Type>(left.upper(), right.upper());
+ && domain_equal<Type>(upper(left), upper(right));
}
//------------------------------------------------------------------------------
@@ -933,7 +951,7 @@
touches(const Type& left, const Type& right)
{
return is_complementary(inner_bounds(left,right))
- && domain_equal<Type>(left.upper(), right.lower());
+ && domain_equal<Type>(upper(left), lower(right));
}
@@ -1055,7 +1073,7 @@
template<class Type>
inline typename enable_if<is_interval<Type>,
typename size_type_of<interval_traits<Type> >::type>::type
-iterative_size(const Type& object)
+iterative_size(const Type&)
{
return 2;
}
@@ -1386,7 +1404,7 @@
if(icl::is_empty(x1) || icl::is_empty(x2))
return icl::identity_element<DiffT>::value();
else if(domain_less<Type>(upper(x1), lower(x2)))
- return x2.lower() - x1.upper();
+ return lower(x2) - upper(x1);
else if(domain_less<Type>(upper(x2), lower(x1)))
return lower(x1) - upper(x2);
else
Modified: sandbox/icl/boost/icl/concept/interval_associator.hpp
==============================================================================
--- sandbox/icl/boost/icl/concept/interval_associator.hpp (original)
+++ sandbox/icl/boost/icl/concept/interval_associator.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -325,6 +325,7 @@
}
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op + (T, c P&) T:{S}|{M} P:{e i S}|{b p M}
//------------------------------------------------------------------------------
@@ -339,6 +340,26 @@
return object += operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator + (const Type& object, const OperandT& operand)
+{
+ Type temp = object;
+ return boost::move(temp += operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator + (Type&& object, const OperandT& operand)
+{
+ return boost::move(object += operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op + (c P&, T) T:{S}|{M} P:{e i S'}|{b p M'}
//------------------------------------------------------------------------------
@@ -353,6 +374,26 @@
return object += operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator + (const OperandT& operand, const Type& object)
+{
+ Type temp = object;
+ return boost::move(temp += operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator + (const OperandT& operand, Type&& object)
+{
+ return boost::move(object += operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op + (T, c P&) T:{S}|{M} P:{S}|{M}
//------------------------------------------------------------------------------
@@ -367,6 +408,38 @@
return object += operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator + (const Type& object, const Type& operand)
+{
+ Type temp = object;
+ return boost::move(temp += operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator + (Type&& object, const Type& operand)
+{
+ return boost::move(object += operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator + (const Type& operand, Type&& object)
+{
+ return boost::move(object += operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator + (Type&& object, Type&& operand)
+{
+ return boost::move(object += operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- Addition |=, |
@@ -404,6 +477,7 @@
return object += operand;
}
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op | (T, c P&) T:{S}|{M} P:{e i S}|{b p M}
//------------------------------------------------------------------------------
@@ -418,6 +492,26 @@
return object += operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator | (const Type& object, const OperandT& operand)
+{
+ Type temp = object;
+ return boost::move(temp += operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator | (Type&& object, const OperandT& operand)
+{
+ return boost::move(object += operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op | (T, c P&) T:{S}|{M} P:{S}|{M}
//------------------------------------------------------------------------------
@@ -432,6 +526,26 @@
return object += operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator | (const OperandT& operand, const Type& object)
+{
+ Type temp = object;
+ return boost::move(temp += operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator | (const OperandT& operand, Type&& object)
+{
+ return boost::move(object += operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op | (T, c P&) T:{S}|{M} P:{S}|{M}
//------------------------------------------------------------------------------
@@ -445,6 +559,39 @@
{
return object += operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator | (const Type& object, const Type& operand)
+{
+ Type temp = object;
+ return boost::move(temp += operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator | (Type&& object, const Type& operand)
+{
+ return boost::move(object += operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator | (const Type& operand, Type&& object)
+{
+ return boost::move(object += operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator | (Type&& object, Type&& operand)
+{
+ return boost::move(object += operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
//==============================================================================
//= Insertion<IntervalSet|IntervalSet>
@@ -458,7 +605,7 @@
{
typename Type::iterator prior_ = object.end();
ICL_const_FORALL(typename OperandT, elem_, operand)
- insert(object, *elem_);
+ insert(object, prior_, *elem_);
return object;
}
@@ -560,7 +707,7 @@
return erase(object, operand);
}
-
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op - (T, c P&) T:{S}|{M} P:{e i S'}|{e i b p S' M'}
//------------------------------------------------------------------------------
@@ -571,6 +718,24 @@
return object -= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_right_inter_combinable<Type, OperandT>, Type>::type
+operator - (const Type& object, const OperandT& operand)
+{
+ Type temp = object;
+ return boost::move(temp -= operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_right_inter_combinable<Type, OperandT>, Type>::type
+operator - (Type&& object, const OperandT& operand)
+{
+ return boost::move(object -= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
//==============================================================================
//= Intersection<IntervalSet|IntervalSet>
@@ -611,6 +776,7 @@
return object;
}
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op & (T, c P&) T:{S}|{M} P:{e i S'}|{e i b p S' M'} S<S' M<M' <:coarser
//------------------------------------------------------------------------------
@@ -621,6 +787,26 @@
return object &= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type
+operator & (const Type& object, const OperandT& operand)
+{
+ Type temp = object;
+ return boost::move(temp &= operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type
+operator & (Type&& object, const OperandT& operand)
+{
+ return boost::move(object &= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op & (c P&, T) T:{S}|{M} P:{e i S'}|{e i b p S' M'} S<S' M<M' <:coarser
//------------------------------------------------------------------------------
@@ -631,6 +817,26 @@
return object &= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type
+operator & (const OperandT& operand, const Type& object)
+{
+ Type temp = object;
+ return boost::move(temp &= operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_inter_combinable<Type, OperandT>, Type>::type
+operator & (const OperandT& operand, Type&& object)
+{
+ return boost::move(object &= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op & (T, c T&) T:{S M}
//------------------------------------------------------------------------------
@@ -641,6 +847,39 @@
return object &= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator & (const Type& object, const Type& operand)
+{
+ Type temp = object;
+ return boost::move(temp &= operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator & (Type&& object, const Type& operand)
+{
+ return boost::move(object &= operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator & (const Type& operand, Type&& object)
+{
+ return boost::move(object &= operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator & (Type&& object, Type&& operand)
+{
+ return boost::move(object &= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
//------------------------------------------------------------------------------
//- intersects<IntervalSet|IntervalMap>
//------------------------------------------------------------------------------
@@ -670,7 +909,7 @@
typename enable_if< mpl::and_< is_intra_combinable<LeftT, RightT>
, mpl::or_<is_total<LeftT>, is_total<RightT> > >
, bool>::type
-intersects(const LeftT& left, const RightT& right)
+intersects(const LeftT&, const RightT&)
{
return true;
}
@@ -772,6 +1011,7 @@
return icl::flip(object, operand);
}
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op ^ (T, c P&) T:{S}|{M} P:{e i S'}|{b p M'} S<S' M<M' <:coarser
//------------------------------------------------------------------------------
@@ -782,6 +1022,26 @@
return object ^= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator ^ (const Type& object, const OperandT& operand)
+{
+ Type temp = object;
+ return boost::move(temp ^= operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator ^ (Type&& object, const OperandT& operand)
+{
+ return boost::move(object ^= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op ^ (c P&, T) T:{S}|{M} P:{e i S'}|{b p M'} S<S' M<M' <:coarser
//------------------------------------------------------------------------------
@@ -792,6 +1052,26 @@
return object ^= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator ^ (const OperandT& operand, const Type& object)
+{
+ Type temp = object;
+ return boost::move(temp ^= operand);
+}
+
+template<class Type, class OperandT>
+typename enable_if<is_binary_intra_combinable<Type, OperandT>, Type>::type
+operator ^ (const OperandT& operand, Type&& object)
+{
+ return boost::move(object ^= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
//------------------------------------------------------------------------------
//- T op ^ (T, c T&) T:{S M}
//------------------------------------------------------------------------------
@@ -802,6 +1082,39 @@
return object ^= operand;
}
+#else //BOOST_NO_RVALUE_REFERENCES
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator ^ (const Type& object, const Type& operand)
+{
+ Type temp = object;
+ return boost::move(temp ^= operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator ^ (Type&& object, const Type& operand)
+{
+ return boost::move(object ^= operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator ^ (const Type& operand, Type&& object)
+{
+ return boost::move(object ^= operand);
+}
+
+template<class Type>
+typename enable_if<is_interval_container<Type>, Type>::type
+operator ^ (Type&& object, Type&& operand)
+{
+ return boost::move(object ^= operand);
+}
+
+#endif //BOOST_NO_RVALUE_REFERENCES
+
//==========================================================================
//= Element Iteration <IntervalSet|IntervalMap>
//==========================================================================
Modified: sandbox/icl/boost/icl/concept/interval_bounds.hpp
==============================================================================
--- sandbox/icl/boost/icl/concept/interval_bounds.hpp (original)
+++ sandbox/icl/boost/icl/concept/interval_bounds.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -85,10 +85,7 @@
shift_lower(interval_bounds decl, interval_bounds repr, const Type& low)
{
if(is_left_closed(decl) && !is_left_closed(repr))
- {
- BOOST_ASSERT((numeric_minimum<Type, is_numeric<Type>::value >::is_less_than(low) ));
return icl::pred(low);
- }
else if(!is_left_closed(decl) && is_left_closed(repr))
return icl::succ(low);
else
@@ -100,10 +97,7 @@
shift_upper(interval_bounds decl, interval_bounds repr, const Type& up)
{
if(!is_right_closed(decl) && is_right_closed(repr))
- {
- BOOST_ASSERT((numeric_minimum<Type, is_numeric<Type>::value >::is_less_than(up) ));
return icl::pred(up);
- }
else if(is_right_closed(decl) && !is_right_closed(repr))
return icl::succ(up);
else
Modified: sandbox/icl/boost/icl/concept/interval_map.hpp
==============================================================================
--- sandbox/icl/boost/icl/concept/interval_map.hpp (original)
+++ sandbox/icl/boost/icl/concept/interval_map.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -88,7 +88,7 @@
, is_total<Type>
, is_cross_derivative<Type, CoType> >
, bool>::type
-contains(const Type& super, const CoType& sub)
+contains(const Type&, const CoType&)
{
return true;
}
Modified: sandbox/icl/boost/icl/continuous_interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/continuous_interval.hpp (original)
+++ sandbox/icl/boost/icl/continuous_interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -30,6 +30,7 @@
public:
typedef continuous_interval<DomainT,Compare> type;
typedef DomainT domain_type;
+ typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
typedef typename bounded_value<DomainT>::type bounded_domain_type;
public:
@@ -161,7 +162,7 @@
template<class DomainT>
struct value_size<icl::continuous_interval<DomainT> >
{
- static std::size_t apply(const icl::continuous_interval<DomainT>& value)
+ static std::size_t apply(const icl::continuous_interval<DomainT>&)
{ return 2; }
};
Modified: sandbox/icl/boost/icl/detail/interval_map_algo.hpp
==============================================================================
--- sandbox/icl/boost/icl/detail/interval_map_algo.hpp (original)
+++ sandbox/icl/boost/icl/detail/interval_map_algo.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -68,8 +68,8 @@
template<class IntervalMapT>
typename enable_if<is_total<IntervalMapT>, bool>::type
-contains(const IntervalMapT& container,
- const typename IntervalMapT::domain_type& key)
+contains(const IntervalMapT&,
+ const typename IntervalMapT::domain_type&)
{
return true;
}
@@ -97,8 +97,8 @@
template<class IntervalMapT>
typename enable_if<is_total<IntervalMapT>, bool>::type
-contains(const IntervalMapT& container,
- const typename IntervalMapT::interval_type& sub_interval)
+contains(const IntervalMapT&,
+ const typename IntervalMapT::interval_type&)
{
return true;
}
@@ -115,7 +115,7 @@
template<class IntervalMapT, class IntervalSetT>
typename enable_if<mpl::and_<is_total<IntervalMapT>
,is_interval_set<IntervalSetT> >, bool>::type
-contains(const IntervalMapT& super_map, const IntervalSetT& sub_set)
+contains(const IntervalMapT&, const IntervalSetT&)
{
return true;
}
Modified: sandbox/icl/boost/icl/discrete_interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/discrete_interval.hpp (original)
+++ sandbox/icl/boost/icl/discrete_interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -30,6 +30,7 @@
public:
typedef discrete_interval<DomainT,Compare> type;
typedef DomainT domain_type;
+ typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
typedef typename bounded_value<DomainT>::type bounded_domain_type;
public:
@@ -158,7 +159,7 @@
template<class DomainT>
struct value_size<icl::discrete_interval<DomainT> >
{
- static std::size_t apply(const icl::discrete_interval<DomainT>& value)
+ static std::size_t apply(const icl::discrete_interval<DomainT>&)
{ return 2; }
};
Modified: sandbox/icl/boost/icl/functors.hpp
==============================================================================
--- sandbox/icl/boost/icl/functors.hpp (original)
+++ sandbox/icl/boost/icl/functors.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -22,14 +22,14 @@
template <typename Type> struct identity_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
+ inline static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
// ------------------------------------------------------------------------
template <typename Type> struct unit_element_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type identity_element() { return boost::icl::unit_element<Type>::value(); }
+ inline static Type identity_element() { return boost::icl::unit_element<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -37,7 +37,7 @@
: public identity_based_inplace_combine<Type>
{
typedef inplace_identity<Type> type;
- void operator()(Type& object, const Type& operand)const{}
+ void operator()(Type&, const Type&)const{}
};
template<>
@@ -49,11 +49,13 @@
: public identity_based_inplace_combine<Type>
{
typedef inplace_erasure<Type> type;
+ typedef identity_based_inplace_combine<Type> base_type;
void operator()(Type& object, const Type& operand)const
{
if(object == operand)
- object = Type();
+ //identity_element(); //JODO Old gcc-3.4.4 does not compile this
+ object = base_type::identity_element(); //<-- but this.
}
};
@@ -70,7 +72,7 @@
void operator()(Type& object, const Type& operand)const
{ object += operand; }
- static void version(Type& object){}
+ static void version(Type&){}
};
template<>
@@ -98,7 +100,7 @@
void operator()(Type& object, const Type& operand)const
{ object |= operand; }
- static void version(Type& object){}
+ static void version(Type&){}
};
template<>
@@ -112,8 +114,6 @@
void operator()(Type& object, const Type& operand)const
{ object &= ~operand; }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -140,8 +140,6 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -165,8 +163,6 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -180,8 +176,6 @@
void operator()(Type& object, const Type& operand)const
{ insert(object,operand); }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -195,8 +189,6 @@
void operator()(Type& object, const Type& operand)const
{ erase(object,operand); }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -204,14 +196,12 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_star
- : public identity_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type> //JODO unit_element_
{
typedef inplace_star<Type> type;
void operator()(Type& object, const Type& operand)const
{ object *= operand; }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -219,14 +209,12 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_slash
- : public identity_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type> //JODO unit_element_
{
typedef inplace_slash<Type> type;
void operator()(Type& object, const Type& operand)const
{ object /= operand; }
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -243,8 +231,6 @@
if(object < operand)
object = operand;
}
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -261,8 +247,6 @@
if(object > operand)
object = operand;
}
-
- static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -340,6 +324,19 @@
struct inverse<icl::inplace_min<Type> >
{ typedef icl::inplace_max<Type> type; };
+ template<class Type>
+ struct inverse<icl::inplace_identity<Type> >
+ { typedef icl::inplace_erasure<Type> type; };
+
+ // If a Functor
+ template<class Functor>
+ struct inverse
+ {
+ typedef typename
+ remove_reference<typename Functor::first_argument_type>::type argument_type;
+ typedef icl::inplace_erasure<argument_type> type;
+ };
+
//--------------------------------------------------------------------------
// Inverse inter_section functor
Modified: sandbox/icl/boost/icl/gregorian.hpp
==============================================================================
--- sandbox/icl/boost/icl/gregorian.hpp (original)
+++ sandbox/icl/boost/icl/gregorian.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -77,12 +77,12 @@
// ------------------------------------------------------------------------
- boost::gregorian::date operator ++(boost::gregorian::date& x)
+ inline boost::gregorian::date operator ++(boost::gregorian::date& x)
{
return x += boost::gregorian::date::duration_type::unit();
}
- boost::gregorian::date operator --(boost::gregorian::date& x)
+ inline boost::gregorian::date operator --(boost::gregorian::date& x)
{
return x -= boost::gregorian::date::duration_type::unit();
}
@@ -107,12 +107,12 @@
typedef boost::gregorian::date_duration type;
};
- boost::gregorian::date_duration operator ++(boost::gregorian::date_duration& x)
+ inline boost::gregorian::date_duration operator ++(boost::gregorian::date_duration& x)
{
return x += boost::gregorian::date::duration_type::unit();
}
- boost::gregorian::date_duration operator --(boost::gregorian::date_duration& x)
+ inline boost::gregorian::date_duration operator --(boost::gregorian::date_duration& x)
{
return x -= boost::gregorian::date::duration_type::unit();
}
Modified: sandbox/icl/boost/icl/impl_config.hpp
==============================================================================
--- sandbox/icl/boost/icl/impl_config.hpp (original)
+++ sandbox/icl/boost/icl/impl_config.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,6 +1,6 @@
/*-----------------------------------------------------------------------------+
Author: Joachim Faulhaber
-Copyright (c) 2009-2009: Joachim Faulhaber
+Copyright (c) 2009-2011: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -10,36 +10,37 @@
#define BOOST_ICL_IMPL_CONFIG_HPP_JOFA_091225
/*-----------------------------------------------------------------------------+
-You can choose an implementation for the basic set and map classes.
-Select at most ONE of the following defines
+| You can choose an implementation for the basic set and map classes. |
+| Select at most ONE of the following defines to change the default |
+-----------------------------------------------------------------------------*/
-//#define ICL_USE_STD_IMPLEMENTATION
-//#define ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION
-//#define ICL_USE_BOOST_MOVE_IMPLEMENTATION
+//#define ICL_USE_STD_IMPLEMENTATION // Default
+//#define ICL_USE_BOOST_MOVE_IMPLEMENTATION // Boost.Container
+// ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION // No longer available
/*-----------------------------------------------------------------------------+
-NO define or ICL_USE_STD_IMPLEMENTATION: Choose std::set and std::map as
- implementing containers (default).
-
-ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION: Choose set and map implementations
- from boost::interprocess.
-
-ICL_USE_BOOST_MOVE_IMPLEMENTATION: Move aware containers from boost::container
- (NEW) are used. Currently (January 2010) this is only experimental.
- boost::move from the boost::sandbox has to be used. This is depreciated for
- production code, as long as move aware containers are not officially
- accepted into boost.
+| NO define or ICL_USE_STD_IMPLEMENTATION: Choose std::set and std::map from |
+| your local std implementation as implementing containers (DEFAULT). |
+| Whether move semantics is available depends on the version of your local |
+| STL. |
+| |
+| ICL_USE_BOOST_MOVE_IMPLEMENTATION: |
+| Use move aware containers from boost::container. |
+| |
+| NOTE: ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION: This define has been |
+| available until boost version 1.48.0 and is no longer supported. |
+-----------------------------------------------------------------------------*/
-#if defined(ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION)
-#define ICL_IMPL_SPACE boost::interprocess
-#elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
-#define ICL_IMPL_SPACE boost::container
+#if defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
+# define ICL_IMPL_SPACE boost::container
+#elif defined(ICL_USE_STD_IMPLEMENTATION)
+# define ICL_IMPL_SPACE std
#else
-#define ICL_IMPL_SPACE std
+# define ICL_IMPL_SPACE std
#endif
+#include <boost/move/move.hpp>
+
#endif // BOOST_ICL_IMPL_CONFIG_HPP_JOFA_091225
Modified: sandbox/icl/boost/icl/interval_base_map.hpp
==============================================================================
--- sandbox/icl/boost/icl/interval_base_map.hpp (original)
+++ sandbox/icl/boost/icl/interval_base_map.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2010: Joachim Faulhaber
+Copyright (c) 2007-2012: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
@@ -193,6 +193,7 @@
BOOST_STATIC_CONSTANT(int, fineness = 0);
public:
+
//==========================================================================
//= Construct, copy, destruct
//==========================================================================
@@ -214,13 +215,37 @@
BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
}
- /** Assignment operator */
+ /** Copy assignment operator */
interval_base_map& operator = (const interval_base_map& src)
{
this->_map = src._map;
return *this;
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /** Move constructor */
+ interval_base_map(interval_base_map&& src): _map(boost::move(src._map))
+ {
+ BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
+ BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+ BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<CodomainT>));
+ BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
+ }
+
+ /** Move assignment operator */
+ interval_base_map& operator = (interval_base_map&& src)
+ {
+ this->_map = boost::move(src._map);
+ return *this;
+ }
+
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
+
/** swap the content of containers */
void swap(interval_base_map& object) { _map.swap(object._map); }
Modified: sandbox/icl/boost/icl/interval_base_set.hpp
==============================================================================
--- sandbox/icl/boost/icl/interval_base_set.hpp (original)
+++ sandbox/icl/boost/icl/interval_base_set.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2009: Joachim Faulhaber
+Copyright (c) 2007-2011: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
@@ -11,12 +11,12 @@
#include <boost/icl/impl_config.hpp>
-#if defined(ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION)
-#include <boost/interprocess/containers/set.hpp>
-#elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
-#include <boost/container/set.hpp>
-#else
-#include <set>
+#if defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
+# include <boost/container/set.hpp>
+#elif defined(ICL_USE_STD_IMPLEMENTATION)
+# include <set>
+#else // Default for implementing containers
+# include <set>
#endif
#include <limits>
@@ -162,7 +162,11 @@
interval_base_set(){}
/** Copy constructor */
- interval_base_set(const interval_base_set& src): _set(src._set){}
+ interval_base_set(const interval_base_set& src): _set(src._set)
+ {
+ BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
+ BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+ }
/** Assignment operator */
interval_base_set& operator = (const interval_base_set& src)
@@ -171,6 +175,28 @@
return *this;
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /** Move constructor */
+ interval_base_set(interval_base_set&& src): _set(boost::move(src._set))
+ {
+ BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
+ BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+ }
+
+ /** Move assignment operator */
+ interval_base_set& operator = (interval_base_set&& src)
+ {
+ this->_set = boost::move(src._set);
+ return *this;
+ }
+
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
+
/** swap the content of containers */
void swap(interval_base_set& operand) { _set.swap(operand._set); }
Modified: sandbox/icl/boost/icl/interval_map.hpp
==============================================================================
--- sandbox/icl/boost/icl/interval_map.hpp (original)
+++ sandbox/icl/boost/icl/interval_map.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2012: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -72,12 +72,13 @@
//==========================================================================
//= Construct, copy, destruct
//==========================================================================
+
/// Default constructor for the empty object
interval_map(): base_type() {}
+
/// Copy constructor
interval_map(const interval_map& src): base_type(src) {}
-
/// Copy constructor for base_type
template<class SubType>
explicit interval_map
@@ -91,6 +92,7 @@
explicit interval_map(const value_type& value_pair): base_type()
{ this->add(value_pair); }
+
/// Assignment operator
template<class SubType>
interval_map& operator =
@@ -106,12 +108,31 @@
typedef interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
this->clear();
- // Can be implemented via _map.insert: Interval joining not necessary.
iterator prior_ = this->_map.end();
ICL_const_FORALL(typename base_map_type, it_, src)
prior_ = this->add(prior_, *it_);
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /// Move constructor
+ interval_map(interval_map&& src)
+ : base_type(boost::move(src))
+ {}
+
+ /// Move assignment operator
+ interval_map& operator = (interval_map&& src)
+ {
+ base_type::operator=(boost::move(src));
+ return *this;
+ }
+
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
+
private:
// Private functions that shall be accessible by the baseclass:
friend class
Modified: sandbox/icl/boost/icl/interval_set.hpp
==============================================================================
--- sandbox/icl/boost/icl/interval_set.hpp (original)
+++ sandbox/icl/boost/icl/interval_set.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -93,6 +93,7 @@
//==========================================================================
/// Default constructor for the empty object
interval_set(): base_type() {}
+
/// Copy constructor
interval_set(const interval_set& src): base_type(src) {}
@@ -107,6 +108,7 @@
/// Constructor for a single element
explicit interval_set(const domain_type& value): base_type()
{ this->add(interval_type(value)); }
+
/// Constructor for a single interval
explicit interval_set(const interval_type& itv): base_type()
{
@@ -135,6 +137,24 @@
prior_ = this->add(prior_, *it_);
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /// Move constructor
+ interval_set(interval_set&& src)
+ : base_type(boost::move(src))
+ {}
+
+ /// Move assignment operator
+ interval_set& operator = (interval_set&& src)
+ {
+ base_type::operator=(boost::move(src));
+ return *this;
+ }
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
private:
// Private functions that shall be accessible by the baseclass:
Modified: sandbox/icl/boost/icl/left_open_interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/left_open_interval.hpp (original)
+++ sandbox/icl/boost/icl/left_open_interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -49,7 +49,8 @@
// Only for discrete types this ctor creates an interval containing
// a single element only.
BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
- BOOST_ASSERT((numeric_minimum<DomainT, is_numeric<DomainT>::value >::is_less_than(val) ));
+ BOOST_ASSERT((numeric_minimum<DomainT, domain_compare, is_numeric<DomainT>::value >
+ ::is_less_than(val) ));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
@@ -108,7 +109,7 @@
template<class DomainT, ICL_COMPARE Compare>
struct value_size<icl::left_open_interval<DomainT,Compare> >
{
- static std::size_t apply(const icl::left_open_interval<DomainT>& value)
+ static std::size_t apply(const icl::left_open_interval<DomainT>&)
{ return 2; }
};
Modified: sandbox/icl/boost/icl/map.hpp
==============================================================================
--- sandbox/icl/boost/icl/map.hpp (original)
+++ sandbox/icl/boost/icl/map.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2010: Joachim Faulhaber
+Copyright (c) 2007-2011: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -10,17 +10,15 @@
#include <boost/icl/impl_config.hpp>
-#if defined(ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION)
-#include <boost/interprocess/containers/map.hpp>
-#include <boost/interprocess/containers/set.hpp>
-#include <boost/interprocess/containers/flat_set.hpp> //FLAS
-#include <boost/interprocess/containers/flat_map.hpp> //FLAS
-#elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
-#include <boost/container/map.hpp>
-#include <boost/container/set.hpp>
-#else
-#include <map>
-#include <set>
+#if defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
+# include <boost/container/map.hpp>
+# include <boost/container/set.hpp>
+#elif defined(ICL_USE_STD_IMPLEMENTATION)
+# include <map>
+# include <set>
+#else // Default for implementing containers
+# include <map>
+# include <set>
#endif
#include <string>
@@ -194,7 +192,34 @@
insert(key_value_pair);
}
- map& operator=(const map& src) { base_type::operator=(src); return *this; }
+ map& operator = (map& src)
+ {
+ base_type::operator=(src);
+ return *this;
+ }
+
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ map(map&& src)
+ : base_type(boost::move(src))
+ {
+ BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
+ BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
+ BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<CodomainT>));
+ BOOST_CONCEPT_ASSERT((EqualComparableConcept<CodomainT>));
+ }
+
+ map& operator = (map&& src)
+ {
+ base_type::operator=(src);
+ return *this;
+ }
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
+
void swap(map& src) { base_type::swap(src); }
//==========================================================================
@@ -310,6 +335,14 @@
return base_type::insert(prior, value_pair);
}
+ template<class Iterator>
+ iterator insert(Iterator first, Iterator last)
+ {
+ iterator prior = end(), it = first;
+ while(it != last)
+ prior = this->insert(prior, *it++);
+ }
+
/** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
map& set(const element_type& key_value_pair)
{
Modified: sandbox/icl/boost/icl/open_interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/open_interval.hpp (original)
+++ sandbox/icl/boost/icl/open_interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -24,6 +24,7 @@
public:
typedef open_interval<DomainT,Compare> type;
typedef DomainT domain_type;
+ typedef ICL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
public:
//==========================================================================
@@ -48,7 +49,8 @@
// Only for discrete types this ctor creates an interval containing
// a single element only.
BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
- BOOST_ASSERT((numeric_minimum<DomainT, is_numeric<DomainT>::value >::is_less_than(val) ));
+ BOOST_ASSERT((numeric_minimum<DomainT, domain_compare, is_numeric<DomainT>::value >
+ ::is_less_than(val) ));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
@@ -107,7 +109,7 @@
template<class DomainT, ICL_COMPARE Compare>
struct value_size<icl::open_interval<DomainT,Compare> >
{
- static std::size_t apply(const icl::open_interval<DomainT>& value)
+ static std::size_t apply(const icl::open_interval<DomainT>&)
{ return 2; }
};
Modified: sandbox/icl/boost/icl/ptime.hpp
==============================================================================
--- sandbox/icl/boost/icl/ptime.hpp (original)
+++ sandbox/icl/boost/icl/ptime.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -76,12 +76,12 @@
};
// ------------------------------------------------------------------------
- boost::posix_time::ptime operator ++(boost::posix_time::ptime& x)
+ inline boost::posix_time::ptime operator ++(boost::posix_time::ptime& x)
{
return x += boost::posix_time::ptime::time_duration_type::unit();
}
- boost::posix_time::ptime operator --(boost::posix_time::ptime& x)
+ inline boost::posix_time::ptime operator --(boost::posix_time::ptime& x)
{
return x -= boost::posix_time::ptime::time_duration_type::unit();
}
@@ -106,12 +106,12 @@
typedef boost::posix_time::time_duration type;
};
- boost::posix_time::time_duration operator ++(boost::posix_time::time_duration& x)
+ inline boost::posix_time::time_duration operator ++(boost::posix_time::time_duration& x)
{
return x += boost::posix_time::ptime::time_duration_type::unit();
}
- boost::posix_time::time_duration operator --(boost::posix_time::time_duration& x)
+ inline boost::posix_time::time_duration operator --(boost::posix_time::time_duration& x)
{
return x -= boost::posix_time::ptime::time_duration_type::unit();
}
Modified: sandbox/icl/boost/icl/right_open_interval.hpp
==============================================================================
--- sandbox/icl/boost/icl/right_open_interval.hpp (original)
+++ sandbox/icl/boost/icl/right_open_interval.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -108,7 +108,7 @@
template<class DomainT, ICL_COMPARE Compare>
struct value_size<icl::right_open_interval<DomainT,Compare> >
{
- static std::size_t apply(const icl::right_open_interval<DomainT>& value)
+ static std::size_t apply(const icl::right_open_interval<DomainT>&)
{ return 2; }
};
Modified: sandbox/icl/boost/icl/separate_interval_set.hpp
==============================================================================
--- sandbox/icl/boost/icl/separate_interval_set.hpp (original)
+++ sandbox/icl/boost/icl/separate_interval_set.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -82,7 +82,6 @@
/// const_iterator for iteration over intervals
typedef typename ImplSetT::const_iterator const_iterator;
-
enum { fineness = 2 };
public:
@@ -124,6 +123,24 @@
this->_set.insert(src.begin(), src.end());
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /// Move constructor
+ separate_interval_set(separate_interval_set&& src)
+ : base_type(boost::move(src))
+ {}
+
+ /// Move assignment operator
+ separate_interval_set& operator = (separate_interval_set&& src)
+ {
+ base_type::operator=(boost::move(src));
+ return *this;
+ }
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
private:
// Private functions that shall be accessible by the baseclass:
Modified: sandbox/icl/boost/icl/set.hpp
==============================================================================
--- sandbox/icl/boost/icl/set.hpp (original)
+++ sandbox/icl/boost/icl/set.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2010: Joachim Faulhaber
+Copyright (c) 2007-2011: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -10,12 +10,12 @@
#include <boost/icl/impl_config.hpp>
-#if defined(ICL_USE_BOOST_INTERPROCESS_IMPLEMENTATION)
-#include <boost/interprocess/containers/set.hpp>
-#elif defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
-#include <boost/container/set.hpp>
+#if defined(ICL_USE_BOOST_MOVE_IMPLEMENTATION)
+# include <boost/container/set.hpp>
+#elif defined(ICL_USE_STD_IMPLEMENTATION)
+# include <set>
#else
-#include <set>
+# include <set>
#endif
#include <boost/icl/concept/associative_element_container.hpp>
Modified: sandbox/icl/boost/icl/split_interval_map.hpp
==============================================================================
--- sandbox/icl/boost/icl/split_interval_map.hpp (original)
+++ sandbox/icl/boost/icl/split_interval_map.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2009: Joachim Faulhaber
+Copyright (c) 2007-2012: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
@@ -68,6 +68,7 @@
//==========================================================================
/// Default constructor for the empty object
split_interval_map(): base_type() {}
+
/// Copy constructor
split_interval_map(const split_interval_map& src): base_type(src) {}
@@ -77,7 +78,7 @@
explicit split_interval_map(const value_type& value_pair): base_type()
{ this->add(value_pair); }
- /// Assignment operator
+ /// Copy assignment operator
template<class SubType>
split_interval_map& operator =
(const interval_base_map<SubType,DomainT,CodomainT,
@@ -93,6 +94,26 @@
this->_map.insert(src.begin(), src.end());
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /// Move constructor
+ split_interval_map(split_interval_map&& src)
+ : base_type(boost::move(src))
+ {}
+
+ /// Move assignment operator
+ split_interval_map& operator = (split_interval_map&& src)
+ {
+ base_type::operator=(boost::move(src));
+ return *this;
+ }
+
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
+
private:
// Private functions that shall be accessible by the baseclass:
friend class
Modified: sandbox/icl/boost/icl/split_interval_set.hpp
==============================================================================
--- sandbox/icl/boost/icl/split_interval_set.hpp (original)
+++ sandbox/icl/boost/icl/split_interval_set.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -118,6 +118,25 @@
this->_set.insert(src.begin(), src.end());
}
+# ifndef BOOST_NO_RVALUE_REFERENCES
+ //==========================================================================
+ //= Move semantics
+ //==========================================================================
+
+ /// Move constructor
+ split_interval_set(split_interval_set&& src)
+ : base_type(boost::move(src))
+ {}
+
+ /// Move assignment operator
+ split_interval_set& operator = (split_interval_set&& src)
+ {
+ base_type::operator=(boost::move(src));
+ return *this;
+ }
+ //==========================================================================
+# endif // BOOST_NO_RVALUE_REFERENCES
+
private:
// Private functions that shall be accessible by the baseclass:
Modified: sandbox/icl/boost/icl/type_traits/infinity.hpp
==============================================================================
--- sandbox/icl/boost/icl/type_traits/infinity.hpp (original)
+++ sandbox/icl/boost/icl/type_traits/infinity.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -12,6 +12,8 @@
#include <boost/static_assert.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/icl/type_traits/is_numeric.hpp>
+#include <boost/icl/type_traits/rep_type_of.hpp>
+#include <boost/icl/type_traits/size_type_of.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/if.hpp>
Modified: sandbox/icl/boost/icl/type_traits/is_discrete.hpp
==============================================================================
--- sandbox/icl/boost/icl/type_traits/is_discrete.hpp (original)
+++ sandbox/icl/boost/icl/type_traits/is_discrete.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -50,7 +50,6 @@
<
has_rep_type<Type>
, is_discrete<typename rep_type_of<Type>::type>
- //CL , is_non_floating_point<typename rep_type_of<Type>::type>
>
>
>::value
Modified: sandbox/icl/boost/icl/type_traits/is_numeric.hpp
==============================================================================
--- sandbox/icl/boost/icl/type_traits/is_numeric.hpp (original)
+++ sandbox/icl/boost/icl/type_traits/is_numeric.hpp 2012-07-22 18:16:26 EDT (Sun, 22 Jul 2012)
@@ -10,6 +10,7 @@
#include <limits>
#include <complex>
+#include <functional>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/is_integral.hpp>
@@ -54,20 +55,28 @@
};
//--------------------------------------------------------------------------
-template<class Type, bool Enable = false> struct numeric_minimum;
-
-template<class Type>
-struct numeric_minimum<Type, false>
+template<class Type, class Compare, bool Enable = false>
+struct numeric_minimum
{
static bool is_less_than(Type){ return true; }
static bool is_less_than_or(Type, bool){ return true; }
};
template<class Type>
-struct numeric_minimum<Type, true>
+struct numeric_minimum<Type, std::less<Type>, true>
+{
+ static bool is_less_than(Type value)
+ { return std::less<Type>()((std::numeric_limits<Type>::min)(), value); }
+
+ static bool is_less_than_or(Type value, bool cond)
+ { return cond || is_less_than(value); }
+};
+
+template<class Type>
+struct numeric_minimum<Type, std::greater<Type>, true>
{
static bool is_less_than(Type value)
- { return (std::numeric_limits<Type>::min)() < value; }
+ { return std::greater<Type>()((std::numeric_limits<Type>::max)(), value); }
static bool is_less_than_or(Type value, bool cond)
{ return cond || is_less_than(value); }
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