Subject: [Boost-commit] svn:boost r70722 - in trunk: boost/chrono boost/icl/concept boost/icl/type_traits libs/icl/test libs/icl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2011-03-29 19:12:55
Author: jofaber
Date: 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
New Revision: 70722
URL: http://svn.boost.org/trac/boost/changeset/70722
Log:
Improved mutual agnostic interoperability between boost::chrono and boost::icl. Added test for chrono-icl interoperability.
Text files modified:
trunk/boost/chrono/duration.hpp | 2
trunk/boost/icl/concept/interval.hpp | 4
trunk/boost/icl/concept/interval_associator.hpp | 2
trunk/boost/icl/type_traits/difference_type_of.hpp | 52 +++++++-
trunk/boost/icl/type_traits/infinity.hpp | 186 +++++++++++++++++++++++++++-----
trunk/boost/icl/type_traits/is_container.hpp | 2
trunk/boost/icl/type_traits/is_discrete.hpp | 25 +++
trunk/boost/icl/type_traits/is_numeric.hpp | 29 ++++
trunk/boost/icl/type_traits/size_type_of.hpp | 55 +++++++++
trunk/libs/icl/test/Jamfile.v2 | 20 +++
trunk/libs/icl/test/fast_stat_interval_map_cases.hpp | 20 +-
trunk/libs/icl/test/test_casual_/test_casual.cpp | 179 ++++++++++++++++++++++++++++---
trunk/libs/icl/test/test_icl_map.hpp | 4
trunk/libs/icl/test/test_interval_map_shared.hpp | 5
trunk/libs/icl/test/test_type_lists.hpp | 228 ++++++++++++++++++++++++++++-----------
15 files changed, 664 insertions(+), 149 deletions(-)
Modified: trunk/boost/chrono/duration.hpp
==============================================================================
--- trunk/boost/chrono/duration.hpp (original)
+++ trunk/boost/chrono/duration.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -446,7 +446,7 @@
>
>
>::type* = 0
- ) : rep_(r) { }
+ ) : rep_(r) { }
~duration() {} //= default;
duration(const duration& rhs) : rep_(rhs.rep_) {} // = default;
duration& operator=(const duration& rhs) // = default;
Modified: trunk/boost/icl/concept/interval.hpp
==============================================================================
--- trunk/boost/icl/concept/interval.hpp (original)
+++ trunk/boost/icl/concept/interval.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -923,7 +923,7 @@
&& domain_equal<Type>(lower(object), upper(object)))
return icl::unit_element<SizeT>::value();
else
- return infinity<SizeT>::value();
+ return icl::infinity<SizeT>::value();
}
template<class Type>
@@ -945,7 +945,7 @@
if(icl::is_empty(object))
return icl::identity_element<SizeT>::value();
else
- return infinity<SizeT>::value();
+ return icl::infinity<SizeT>::value();
}
template<class Type>
Modified: trunk/boost/icl/concept/interval_associator.hpp
==============================================================================
--- trunk/boost/icl/concept/interval_associator.hpp (original)
+++ trunk/boost/icl/concept/interval_associator.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -146,7 +146,7 @@
ICL_const_FORALL(typename Type, it, object)
{
interval_size = icl::cardinality(key_value<Type>(it));
- if(interval_size == infinity<size_type>::value())
+ if(interval_size == icl::infinity<size_type>::value())
return interval_size;
else
size += interval_size;
Modified: trunk/boost/icl/type_traits/difference_type_of.hpp
==============================================================================
--- trunk/boost/icl/type_traits/difference_type_of.hpp (original)
+++ trunk/boost/icl/type_traits/difference_type_of.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -11,50 +11,88 @@
#include <boost/config.hpp> // For macro BOOST_STATIC_CONSTANT
#include <boost/type_traits/is_pointer.hpp>
#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
#include <boost/icl/type_traits/no_type.hpp>
#include <boost/icl/type_traits/is_numeric.hpp>
+#include <boost/icl/type_traits/rep_type_of.hpp>
namespace boost{ namespace icl
{
+ namespace detail
+ {
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
+ }
+
+ //--------------------------------------------------------------------------
+ template <class Type>
+ struct has_difference_type
+ : mpl::bool_<detail::has_difference_type<Type>::value>
+ {};
+
+ //--------------------------------------------------------------------------
+ template<class Type> // type_of(T-T)==T
+ struct is_subtraction_closed
+ {
+ typedef is_subtraction_closed type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (mpl::or_< is_numeric<Type>
+ , mpl::and_< has_rep_type<Type>
+ , mpl::not_<has_difference_type<Type> >
+ >
+ >::value)
+ );
+ };
+
//--------------------------------------------------------------------------
template<class Type>
struct has_difference
{
typedef has_difference type;
BOOST_STATIC_CONSTANT(bool,
- value = (mpl::or_< is_numeric<Type>
- , is_pointer<Type> >::value)
+ value = (mpl::or_< is_subtraction_closed<Type>
+ , is_pointer<Type>
+ , has_difference_type<Type> >::value)
);
};
//--------------------------------------------------------------------------
- template <class Type, bool has_difference>
+ template <class Type, bool has_difference, bool has_diff_type>
struct get_difference_type;
template <class Type>
- struct get_difference_type<Type, false>
+ struct get_difference_type<Type, false, false>
{
typedef no_type type;
};
template <class Type>
- struct get_difference_type<Type*, true>
+ struct get_difference_type<Type*, true, false>
{
typedef std::ptrdiff_t type;
};
template <class Type>
- struct get_difference_type<Type, true>
+ struct get_difference_type<Type, true, false>
{
typedef Type type;
};
+ template <class Type>
+ struct get_difference_type<Type, true, true>
+ {
+ typedef typename Type::difference_type type;
+ };
+
//--------------------------------------------------------------------------
template<class Type>
struct difference_type_of
{
typedef typename
- get_difference_type<Type, has_difference<Type>::value>::type type;
+ get_difference_type< Type
+ , has_difference<Type>::value
+ , has_difference_type<Type>::value
+ >::type type;
};
}} // namespace boost icl
Modified: trunk/boost/icl/type_traits/infinity.hpp
==============================================================================
--- trunk/boost/icl/type_traits/infinity.hpp (original)
+++ trunk/boost/icl/type_traits/infinity.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2010-2010: Joachim Faulhaber
+Copyright (c) 2010-2011: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -10,48 +10,170 @@
#include <string>
#include <boost/static_assert.hpp>
+#include <boost/type_traits/ice.hpp>
#include <boost/icl/type_traits/is_numeric.hpp>
+#include <boost/mpl/and.hpp>
#include <boost/mpl/if.hpp>
namespace boost{ namespace icl
{
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
- template <class Type> struct numeric_infinity
- {
- typedef numeric_infinity type;
-
- static Type value()
- {
- BOOST_STATIC_ASSERT((is_numeric<Type>::value));
- if(std::numeric_limits<Type>::has_infinity)
- return std::numeric_limits<Type>::infinity();
- else
- return (std::numeric_limits<Type>::max)();
- }
- };
+template<class Type> struct has_std_infinity
+{
+ typedef has_std_infinity type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (type_traits::ice_and
+ < is_numeric<Type>::value
+ , std::numeric_limits<Type>::has_infinity
+ >::value)
+ );
+};
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
+template<class Type> struct has_max_infinity
+{
+ typedef has_max_infinity type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (type_traits::ice_and
+ < is_numeric<Type>::value
+ , type_traits::ice_not<std::numeric_limits<Type>::has_infinity>::value
+ >::value)
+ );
+};
+
+//------------------------------------------------------------------------------
+template <class Type, bool has_std_inf=false, bool has_std_max=false>
+struct get_numeric_infinity;
+template <class Type, bool has_std_max>
+struct get_numeric_infinity<Type, true, has_std_max>
+{
+ typedef get_numeric_infinity type;
+ static Type value()
+ {
+ return (std::numeric_limits<Type>::infinity)();
+ }
+};
- template <class Type> struct infinity
+template <class Type>
+struct get_numeric_infinity<Type, false, true>
+{
+ typedef get_numeric_infinity type;
+ static Type value()
{
- typedef infinity type;
+ return (std::numeric_limits<Type>::max)();
+ }
+};
- static Type value()
- {
- return
- mpl::if_<is_numeric<Type>,
- numeric_infinity<Type>,
- identity_element<Type> >::type::value();
- }
- };
+template <class Type>
+struct get_numeric_infinity<Type, false, false>
+{
+ typedef get_numeric_infinity type;
+ static Type value()
+ {
+ return Type();
+ }
+};
+
+template <class Type>
+struct numeric_infinity
+{
+ typedef numeric_infinity type;
+ static Type value()
+ {
+ return get_numeric_infinity< Type
+ , has_std_infinity<Type>::value
+ , has_max_infinity<Type>::value >::value();
+ }
+};
+
+
+//------------------------------------------------------------------------------
+template<class Type, bool has_numeric_inf, bool has_repr_inf, bool has_size, bool has_diff>
+struct get_infinity;
+
+template<class Type, bool has_repr_inf, bool has_size, bool has_diff>
+struct get_infinity<Type, true, has_repr_inf, has_size, has_diff>
+{
+ typedef get_infinity type;
+
+ static Type value()
+ {
+ return numeric_infinity<Type>::value();
+ }
+};
+
+template<class Type, bool has_size, bool has_diff>
+struct get_infinity<Type, false, true, has_size, has_diff>
+{
+ typedef get_infinity type;
+
+ static Type value()
+ {
+ return Type(numeric_infinity<typename Type::rep>::value());
+ }
+};
+
+template<class Type, bool has_diff>
+struct get_infinity<Type, false, false, true, has_diff>
+{
+ typedef get_infinity type;
+ typedef typename Type::size_type size_type;
+
+ static Type value()
+ {
+ return Type(numeric_infinity<size_type>::value());
+ }
+};
+
+template<class Type>
+struct get_infinity<Type, false, false, false, true>
+{
+ typedef get_infinity type;
+ typedef typename Type::difference_type difference_type;
+
+ static Type value()
+ {
+ return identity_element<difference_type>::value();
+ }
+};
+
+template<class Type>
+struct get_infinity<Type, false, false, false, false>
+{
+ typedef get_infinity type;
+
+ static Type value()
+ {
+ return identity_element<Type>::value();
+ }
+};
+
+template <class Type> struct infinity
+{
+ typedef infinity type;
+
+ static Type value()
+ {
+ return
+ get_infinity< Type
+ , is_numeric<Type>::value
+ , has_rep_type<Type>::value
+ , has_size_type<Type>::value
+ , has_difference_type<Type>::value
+ >::value();
+ }
+};
+
+template <>
+struct infinity<std::string>
+{
+ typedef infinity type;
+
+ static std::string value()
+ {
+ return std::string();
+ }
+};
}} // namespace boost icl
Modified: trunk/boost/icl/type_traits/is_container.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_container.hpp (original)
+++ trunk/boost/icl/type_traits/is_container.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -15,6 +15,7 @@
#include <boost/type_traits/is_same.hpp>
#include <boost/icl/type_traits/element_type_of.hpp>
#include <boost/icl/type_traits/segment_type_of.hpp>
+#include <boost/icl/type_traits/size_type_of.hpp>
#include <boost/icl/type_traits/is_map.hpp>
namespace boost{ namespace icl
@@ -22,7 +23,6 @@
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
}
Modified: trunk/boost/icl/type_traits/is_discrete.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_discrete.hpp (original)
+++ trunk/boost/icl/type_traits/is_discrete.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -26,6 +26,8 @@
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/icl/type_traits/rep_type_of.hpp>
+#include <boost/icl/type_traits/is_numeric.hpp>
namespace boost{ namespace icl
{
@@ -33,9 +35,26 @@
{
typedef is_discrete type;
BOOST_STATIC_CONSTANT(bool,
- value = (mpl::and_< boost::detail::is_incrementable<Type>
- , mpl::not_<is_floating_point<Type> >
- >::value)
+ value =
+ (mpl::and_
+ <
+ boost::detail::is_incrementable<Type>
+ , mpl::or_
+ <
+ mpl::and_
+ <
+ mpl::not_<has_rep_type<Type> >
+ , is_non_floating_point<Type>
+ >
+ , mpl::and_
+ <
+ 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: trunk/boost/icl/type_traits/is_numeric.hpp
==============================================================================
--- trunk/boost/icl/type_traits/is_numeric.hpp (original)
+++ trunk/boost/icl/type_traits/is_numeric.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -10,6 +10,8 @@
#include <limits>
#include <complex>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/is_integral.hpp>
namespace boost{ namespace icl
{
@@ -20,11 +22,27 @@
BOOST_STATIC_CONSTANT(bool, value = (0 < std::numeric_limits<Type>::digits));
};
+template <class Type> struct is_std_numeric
+{
+ typedef is_std_numeric type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (std::numeric_limits<Type>::is_specialized));
+};
+
+template <class Type> struct is_std_integral
+{
+ typedef is_std_integral type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (std::numeric_limits<Type>::is_integer));
+};
+
template <class Type> struct is_numeric
{
typedef is_numeric type;
BOOST_STATIC_CONSTANT(bool, value =
- (mpl::or_<is_fixed_numeric<Type>, is_integral<Type> >::value) );
+ (mpl::or_< is_std_numeric<Type>
+ , boost::is_integral<Type>
+ , is_std_integral<Type> >::value) );
};
template <class Type>
@@ -54,6 +72,15 @@
{ return cond || is_less_than(value); }
};
+//--------------------------------------------------------------------------
+template<class Type>
+struct is_non_floating_point
+{
+ typedef is_non_floating_point type;
+ BOOST_STATIC_CONSTANT(bool, value =
+ (mpl::not_< is_floating_point<Type> >::value));
+};
+
}} // namespace boost icl
#endif
Modified: trunk/boost/icl/type_traits/size_type_of.hpp
==============================================================================
--- trunk/boost/icl/type_traits/size_type_of.hpp (original)
+++ trunk/boost/icl/type_traits/size_type_of.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -8,9 +8,62 @@
#ifndef BOOST_ICL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
#define BOOST_ICL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
+#include <boost/icl/type_traits/difference_type_of.hpp>
+
namespace boost{ namespace icl
{
- template <class Type> struct size_type_of{ typedef std::size_t type; };
+
+ namespace detail
+ {
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
+ }
+
+ //--------------------------------------------------------------------------
+ template <class Type>
+ struct has_size_type
+ : mpl::bool_<detail::has_size_type<Type>::value>
+ {};
+
+ //--------------------------------------------------------------------------
+ template <class Type, bool has_size, bool has_diff, bool has_rep>
+ struct get_size_type;
+
+ template <class Type>
+ struct get_size_type<Type, false, false, false>
+ {
+ typedef std::size_t type;
+ };
+
+ template <class Type, bool has_diff, bool has_rep>
+ struct get_size_type<Type, true, has_diff, has_rep>
+ {
+ typedef typename Type::size_type type;
+ };
+
+ template <class Type, bool has_rep>
+ struct get_size_type<Type, false, true, has_rep>
+ {
+ typedef typename Type::difference_type type;
+ };
+
+ template <class Type>
+ struct get_size_type<Type, false, false, true>
+ {
+ typedef Type type;
+ };
+
+ //--------------------------------------------------------------------------
+ template<class Type>
+ struct size_type_of
+ {
+ typedef typename
+ get_size_type< Type
+ , has_size_type<Type>::value
+ , has_difference_type<Type>::value
+ , has_rep_type<Type>::value
+ >::type type;
+ };
+
}} // namespace boost icl
#endif
Modified: trunk/libs/icl/test/Jamfile.v2
==============================================================================
--- trunk/libs/icl/test/Jamfile.v2 (original)
+++ trunk/libs/icl/test/Jamfile.v2 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -10,6 +10,7 @@
: requirements
<library>/boost/test//boost_unit_test_framework
<library>/boost/date_time//boost_date_time
+ <library>/boost/chrono//boost_chrono
<link>static
<include>../../..
;
@@ -78,5 +79,22 @@
# Ad hoc -----------------------------------------------------------------
#[ run test_casual_/test_casual.cpp ]
-
+
+
+ # ------------------------------------------------------------------------
+ # Chrono -----------------------------------------------------------------
+ # interval
+ [ run fastest_icl_interval_/fastest_icl_interval.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_icl_interval ]
+
+ # sets
+ [ run fastest_interval_set_/fastest_interval_set.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_icl_interval_set ]
+
+ [ run fastest_interval_set_infix_/fastest_interval_set_infix.cpp
+ : : : <define>BOOST_ICL_TEST_CHRONO
+ : chrono_icl_interval_set_infix ]
+
;
Modified: trunk/libs/icl/test/fast_stat_interval_map_cases.hpp
==============================================================================
--- trunk/libs/icl/test/fast_stat_interval_map_cases.hpp (original)
+++ trunk/libs/icl/test/fast_stat_interval_map_cases.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -10,31 +10,31 @@
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_fundamentals_4_ordered_types)
-{ interval_map_fundamentals_4_ordered_types<INTERVAL_MAP, ordered_type_1, int>();}
+{ interval_map_fundamentals_4_ordered_types<INTERVAL_MAP, discrete_type_1, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_ctor_4_bicremental_types)
-{ interval_map_ctor_4_bicremental_types<INTERVAL_MAP, bicremental_type_1, int>();}
+{ interval_map_ctor_4_bicremental_types<INTERVAL_MAP, discrete_type_2, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_add_sub_4_bicremental_types)
-{ interval_map_add_sub_4_bicremental_types<INTERVAL_MAP, bicremental_type_2, int>();}
+{ interval_map_add_sub_4_bicremental_types<INTERVAL_MAP, discrete_type_3, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_contains_4_bicremental_types)
-{ interval_map_contains_4_bicremental_types<INTERVAL_MAP, discrete_type_5, int>();}
+{ interval_map_contains_4_bicremental_types<INTERVAL_MAP, discrete_type_4, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_contains_key_objects_4_bicremental_types)
-{ interval_map_contains_key_objects_4_bicremental_types<INTERVAL_MAP, discrete_type_4, int>();}
+{ interval_map_contains_key_objects_4_bicremental_types<INTERVAL_MAP, discrete_type_5, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_operators_4_bicremental_types)
-{ interval_map_operators_4_bicremental_types<INTERVAL_MAP, bicremental_type_5, int>();}
+{ interval_map_operators_4_bicremental_types<INTERVAL_MAP, discrete_type_6, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_base_intersect_4_bicremental_types)
-{ interval_map_base_intersect_4_bicremental_types<INTERVAL_MAP, bicremental_type_6, int>();}
+{ interval_map_base_intersect_4_bicremental_types<INTERVAL_MAP, discrete_type_1, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_base_erase_4_bicremental_types)
@@ -42,11 +42,11 @@
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_base_is_disjoint_4_bicremental_types)
-{ interval_map_base_is_disjoint_4_bicremental_types<INTERVAL_MAP, bicremental_type_8, int>();}
+{ interval_map_base_is_disjoint_4_bicremental_types<INTERVAL_MAP, discrete_type_8, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_flip_4_bicremental_types)
-{ interval_map_flip_4_bicremental_types<INTERVAL_MAP, bicremental_type_1, int>();}
+{ interval_map_flip_4_bicremental_types<INTERVAL_MAP, discrete_type_1, int>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_find_4_bicremental_types)
@@ -70,7 +70,7 @@
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_std_copy_via_inserter_4_bicremental_types)
-{ interval_map_std_copy_via_inserter_4_bicremental_types<signed_bicremental_type_1, int, partial_absorber, INTERVAL_MAP>();}
+{ interval_map_std_copy_via_inserter_4_bicremental_types<signed_discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
(fastest_icl_interval_map_element_iter_4_discrete_types)
Modified: trunk/libs/icl/test/test_casual_/test_casual.cpp
==============================================================================
--- trunk/libs/icl/test/test_casual_/test_casual.cpp (original)
+++ trunk/libs/icl/test/test_casual_/test_casual.cpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -20,6 +20,9 @@
#include "../test_type_lists.hpp"
#include "../test_value_maker.hpp"
+#include <boost/rational.hpp>
+#include <boost/icl/chrono.hpp>
+
#include <boost/type_traits/is_same.hpp>
#include <boost/icl/gregorian.hpp>
@@ -30,11 +33,151 @@
#include <boost/icl/interval_set.hpp>
#include <boost/icl/interval.hpp>
+
+
using namespace std;
using namespace boost;
using namespace unit_test;
using namespace boost::icl;
+namespace boost{ namespace scalars
+{
+/*
+template<class Origin = constant<0>, class Factor = ratio<1,1>, class Rep>
+class scalar
+{
+public:
+private:
+
+}
+*/
+}} //namespace boost scalars
+
+class MyInt
+{
+public:
+ MyInt():_rep() { cout << "default constructed\n"; }
+ int value()const { return _rep; }
+private:
+ int _rep;
+};
+
+BOOST_AUTO_TEST_CASE(chrono_duration_ctor)
+{
+ using namespace boost::chrono;
+
+ chrono::duration<int> cd_default0 = chrono::duration<int>();
+ cout << "chrono::duration<int>() = " << cd_default0 << endl;
+
+ chrono::duration<double> cd_default1 = chrono::duration<double>();
+ cout << "chrono::duration<double>() = " << cd_default1 << endl;
+
+ chrono::duration<rational<int> > cd_default2 = chrono::duration<rational<int> >();
+ cout << "chrono::duration<rational<int> >() = " << cd_default2 << endl;
+
+ chrono::duration<complex<float> > cd_default3 = chrono::duration<complex<float> >();
+ cout << "chrono::duration<complex<float> >() = " << cd_default3 << endl;
+
+/*
+ chrono::duration<MyInt> cd_default = chrono::duration<MyInt>();
+ cout << "chrono::duration<MyInt>() = " << cd_default.count().value() << endl;
+ cout << "===============================\n";
+
+ duration<int, ratio<60> > min1(1);
+ duration<int, ratio<1,100> > centi1(1);
+ duration<int, ratio<1,100> > centi2 = min1 + centi1;
+ cout << "centi2 = " << centi2 << " centi2.count() = " << centi2.count() << endl;
+
+ centi2 += centi1;
+ cout << "++centi2=" << centi2 << " centi2.count() = " << centi2.count() << endl;
+*/
+}
+
+BOOST_AUTO_TEST_CASE(test_difference_types)
+{
+ BOOST_CHECK(( boost::is_same< int, difference_type_of<int>::type >::value ));
+ BOOST_CHECK(( boost::is_same< double, difference_type_of<double>::type >::value ));
+ BOOST_CHECK(( boost::is_same< std::ptrdiff_t, difference_type_of<int*>::type >::value ));
+
+ BOOST_CHECK(( has_difference_type<std::string>::value ));
+ BOOST_CHECK(( boost::is_same< std::string::difference_type, difference_type_of<std::string>::type >::value ));
+ BOOST_CHECK(( boost::is_same< std::ptrdiff_t, difference_type_of<std::string>::type >::value ));
+
+ BOOST_CHECK(( boost::is_same< chrono::duration<int>
+ , difference_type_of<chrono::duration<int> >::type >::value ));
+ BOOST_CHECK(( boost::is_same< chrono::duration<double>
+ , difference_type_of<chrono::duration<double> >::type >::value ));
+
+ BOOST_CHECK(( boost::is_same< Now::time_point::duration
+ , difference_type_of<Now::time_point>::type >::value ));
+
+ typedef boost::chrono::time_point<Now, boost::chrono::duration<double> > contin_timeT;
+ BOOST_CHECK(( boost::is_same< contin_timeT::duration
+ , difference_type_of<contin_timeT>::type >::value ));
+
+ typedef boost::chrono::time_point<Now, boost::chrono::duration<int> > discr_timeT;
+ BOOST_CHECK(( boost::is_same< chrono::duration<int>
+ , difference_type_of<discr_timeT>::type >::value ));
+}
+
+BOOST_AUTO_TEST_CASE(test_size_types)
+{
+ BOOST_CHECK(( boost::is_same< std::size_t, size_type_of<int>::type >::value ));
+ BOOST_CHECK(( boost::is_same< std::size_t, size_type_of<double>::type >::value ));
+ BOOST_CHECK(( boost::is_same< std::size_t, size_type_of<int*>::type >::value ));
+ BOOST_CHECK(( boost::is_same< std::size_t, size_type_of<std::string>::type >::value ));
+ BOOST_CHECK(( boost::is_same< chrono::duration<int>
+ , size_type_of<chrono::duration<int> >::type >::value ));
+ BOOST_CHECK(( boost::is_same< chrono::duration<double>
+ , size_type_of<chrono::duration<double> >::type >::value ));
+
+ typedef boost::chrono::time_point<Now, boost::chrono::duration<int> > discr_timeT;
+ BOOST_CHECK(( boost::is_same< chrono::duration<int>
+ , size_type_of<discr_timeT>::type >::value ));
+
+ typedef boost::chrono::time_point<Now, boost::chrono::duration<double> > contin_timeT;
+ BOOST_CHECK(( boost::is_same< contin_timeT::duration
+ , size_type_of<contin_timeT>::type >::value ));
+}
+
+BOOST_AUTO_TEST_CASE(test_chrono_identity_elements)
+{
+ chrono::duration<int> idel_i = icl::identity_element<chrono::duration<int> >::value();
+ cout << "dur<int>0 = " << idel_i << endl;
+ chrono::duration<double> idel_d = icl::identity_element<chrono::duration<int> >::value();
+ cout << "dur<dbl>0 = " << idel_d << endl;
+
+ BOOST_CHECK(( boost::is_same< chrono::duration<int>
+ , size_type_of<chrono::duration<int> >::type >::value ));
+}
+
+
+
+BOOST_AUTO_TEST_CASE(test_infinities)
+{
+ BOOST_CHECK(( has_std_infinity<double>::value));
+ BOOST_CHECK((!has_std_infinity<int>::value));
+
+ BOOST_CHECK(( has_max_infinity<int>::value ));
+ BOOST_CHECK((!has_max_infinity<double>::value ));
+
+ //--------------------------------------------------------------------------
+ BOOST_CHECK_EQUAL( numeric_infinity<double>::value(), (std::numeric_limits<double>::infinity)() );
+ BOOST_CHECK_EQUAL( numeric_infinity<int>::value(), (std::numeric_limits<int>::max)() );
+ BOOST_CHECK_EQUAL( numeric_infinity<std::string>::value(), std::string() );
+
+ //--------------------------------------------------------------------------
+ BOOST_CHECK_EQUAL( infinity<double>::value(), (std::numeric_limits<double>::infinity)() );
+ BOOST_CHECK_EQUAL( infinity<int>::value(), (std::numeric_limits<int>::max)() );
+ BOOST_CHECK_EQUAL( infinity<std::string>::value(), identity_element<std::string>::value() );
+
+ //--------------------------------------------------------------------------
+ BOOST_CHECK_EQUAL( infinity<chrono::duration<double> >::value()
+ , chrono::duration<double>((std::numeric_limits<double>::infinity)()) );
+ BOOST_CHECK_EQUAL( infinity<chrono::duration<int> >::value()
+ , chrono::duration<int>((std::numeric_limits<int>::max)()) );
+
+}
BOOST_AUTO_TEST_CASE(casual)
{
@@ -44,24 +187,24 @@
//typedef interval_set<T> IntervalSetT;
//typedef IntervalMapT::interval_type IntervalT;
- /*
- int i;
- int j = int();
- chrono::duration<int> cd1 = chrono::duration<int>();
- chrono::duration<int> cd2(0);
- chrono::duration<int> dur1(0);
- chrono::duration<int> dur2, dur3, dur4;
- dur2 = dur3 = dur4 = dur1;
- int itg1(0);
- int itg2, itg3, itg4;
- itg2 = itg3 = itg4 = itg1;
-
- cout << "uninitialized i = " << i << endl;
- cout << "default constructed j = " << j << endl;
- cout << (cd1==cd2 ? "eq" : "!eq") << endl;
- cout << "chrono::duration cd1() = " << cd1 << endl;
- cout << "chrono::duration cd2(0) = " << cd2 << endl;
- */
+ BOOST_CHECK((has_std_infinity<double>::value));
+
+ BOOST_CHECK((boost::detail::is_incrementable<chrono::duration<int> >::value));
+
+ BOOST_CHECK((has_rep_type<chrono::duration<int> >::value));
+ BOOST_CHECK((represents<int, chrono::duration<int> >::value));
+
+ BOOST_CHECK((!is_discrete<chrono::duration<double> >::value));
+
+ //BOOST_CHECK((!is_discrete<Now_time_rational>::value));
+ BOOST_CHECK(( is_continuous<boost::rational<int> >::value));
+ BOOST_CHECK(( !is_discrete<boost::rational<int> >::value));
+
+ BOOST_CHECK(( has_rep_type<Now_time_rational>::value));
+ BOOST_CHECK(( is_continuous<Now_time_rational>::value));
+ BOOST_CHECK(( !is_discrete<Now_time_rational>::value));
+ BOOST_CHECK(( is_continuous<typename rep_type_of<Now_time_rational>::type>::value));
+
BOOST_CHECK_EQUAL(true, true);
}
Modified: trunk/libs/icl/test/test_icl_map.hpp
==============================================================================
--- trunk/libs/icl/test/test_icl_map.hpp (original)
+++ trunk/libs/icl/test/test_icl_map.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -32,8 +32,8 @@
MapT map_a;
segmental::atomize(map_a, itv_map_a);
- BOOST_CHECK_EQUAL( contains(map_a, MK_u(3)), true );
- BOOST_CHECK_EQUAL( within(MK_u(3), map_a), true );
+ BOOST_CHECK_EQUAL( contains(map_a, MK_v(3)), true );
+ BOOST_CHECK_EQUAL( within(MK_v(3), map_a), true );
map_element_type key_value_pair(MK_v(6), MK_u(3));
BOOST_CHECK( contains(map_a, key_value_pair) );
Modified: trunk/libs/icl/test/test_interval_map_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_map_shared.hpp (original)
+++ trunk/libs/icl/test/test_interval_map_shared.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -1183,11 +1183,12 @@
>
void interval_map_find_4_numeric_continuous_types()
{
+#ifndef BOOST_ICL_TEST_CHRONO
typedef IntervalMap<T,U> IntervalMapT;
typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::const_iterator c_iterator;
- T q_1_2 = MK_v(1) / MK_v(2);
+ T q_1_2 = MK_v(1) / MK_v(2);//JODO Doesn't work with chrono
T q_3_2 = MK_v(3) / MK_v(2);
T q_1_3 = MK_v(1) / MK_v(3);
T q_2_3 = MK_v(2) / MK_v(3);
@@ -1232,7 +1233,7 @@
BOOST_CHECK( !icl::contains(map_a, MK_v(1)) );
BOOST_CHECK( icl::contains(map_a, q_3_2) );
BOOST_CHECK( !icl::contains(map_a, MK_v(2)) );
-
+#endif
}
Modified: trunk/libs/icl/test/test_type_lists.hpp
==============================================================================
--- trunk/libs/icl/test/test_type_lists.hpp (original)
+++ trunk/libs/icl/test/test_type_lists.hpp 2011-03-29 19:12:53 EDT (Tue, 29 Mar 2011)
@@ -18,27 +18,29 @@
#include <boost/icl/ptime.hpp>
#ifdef BOOST_ICL_TEST_XINT
-#include <boost/icl/xint.hpp>
+# include <boost/icl/xint.hpp>
#endif
#ifdef BOOST_ICL_TEST_CHRONO
-//JODO not working: #define BOOST_CHRONO_INLINED
-#include <boost/icl/chrono.hpp>
+# define BOOST_CHRONO_EXTENSIONS
+# include <libs/icl/test/chrono/utility.hpp>
+
+ namespace boch = boost::chrono;
#endif
#include <boost/icl/rational.hpp>
#if(_MSC_VER < 1500 && defined(_DEBUG) ) // 1500 = MSVC-9.0
-typedef int boost_posix_time_ptime;
-typedef int boost_posix_time_duration;
-typedef int boost_gregorian_date;
-typedef int boost_gregorian_date_duration;
-#else
-typedef boost::posix_time::ptime boost_posix_time_ptime;
-typedef boost::posix_time::time_duration boost_posix_time_duration;
-typedef boost::gregorian::date boost_gregorian_date;
-typedef boost::gregorian::date_duration boost_gregorian_date_duration;
+ typedef int boost_posix_time_ptime;
+ typedef int boost_posix_time_duration;
+ typedef int boost_gregorian_date;
+ typedef int boost_gregorian_date_duration;
+#else
+ typedef boost::posix_time::ptime boost_posix_time_ptime;
+ typedef boost::posix_time::time_duration boost_posix_time_duration;
+ typedef boost::gregorian::date boost_gregorian_date;
+ typedef boost::gregorian::date_duration boost_gregorian_date_duration;
#endif
typedef ::boost::mpl::list<
@@ -51,8 +53,10 @@
,boost::rational<boost::xint::integer>
#endif
#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<int>
- ,boost::chrono::duration<double>
+ ,boch::duration<int>
+ ,boch::duration<double>
+ ,Now::time_point
+ ,boch::time_point<Now, boch::duration<double> >
#endif
,boost_posix_time_ptime
,boost_posix_time_duration
@@ -61,15 +65,33 @@
,int*
> bicremental_types;
-typedef unsigned int bicremental_type_1;
-typedef int bicremental_type_2;
-typedef double bicremental_type_3;
-typedef boost::rational<int> bicremental_type_4;
-typedef boost_posix_time_ptime bicremental_type_5;
-typedef short bicremental_type_6;
-typedef float bicremental_type_7;
-typedef int* bicremental_type_8;
-
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<long long, boost::ratio<1,113> > duration_long2_113s;
+ typedef boch::duration<int, boost::ratio<11,113> > duration_int_11_113s;
+ typedef boch::duration<boost::rational<int>, boost::ratio<101,997> > duration_rational_101_997s;
+ typedef boch::time_point<Now, duration_int_11_113s > Now_time_int_11_113s;
+ typedef boch::time_point<Now, boch::duration<double> > Now_time_double;
+ typedef boch::time_point<Now, boch::duration<boost::rational<int> > > Now_time_rational;
+ typedef boch::time_point<Now, duration_rational_101_997s > Now_time_rational_101_997s;
+
+ typedef boch::duration<int> bicremental_type_1;
+ typedef boch::duration<double> bicremental_type_2;
+ typedef Now::time_point bicremental_type_3;
+ typedef Now_time_double bicremental_type_4;
+ typedef Now_time_rational bicremental_type_5;
+ typedef duration_long2_113s bicremental_type_6;
+ typedef duration_rational_101_997s bicremental_type_7;
+ typedef Now_time_rational_101_997s bicremental_type_8;
+#else
+ typedef unsigned int bicremental_type_1;
+ typedef int bicremental_type_2;
+ typedef double bicremental_type_3;
+ typedef boost::rational<int> bicremental_type_4;
+ typedef boost_posix_time_ptime bicremental_type_5;
+ typedef short bicremental_type_6;
+ typedef float bicremental_type_7;
+ typedef int* bicremental_type_8;
+#endif //BOOST_ICL_TEST_CHRONO
typedef ::boost::mpl::list<
short, int, long, long long
@@ -80,16 +102,25 @@
,boost::rational<boost::xint::integer>
#endif
#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<int>
- ,boost::chrono::duration<float>
+ ,boch::duration<int>
+ ,boch::duration<float>
+ ,Now::time_point
#endif
> signed_bicremental_types;
-typedef int signed_bicremental_type_1;
-typedef double signed_bicremental_type_2;
-typedef boost::rational<int> signed_bicremental_type_3;
-typedef short signed_bicremental_type_4;
-typedef float signed_bicremental_type_5;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<int> signed_bicremental_type_1;
+ typedef boch::duration<double> signed_bicremental_type_2;
+ typedef Now::time_point signed_bicremental_type_3;
+ typedef Now_time_double signed_bicremental_type_4;
+ typedef Now_time_rational signed_bicremental_type_5;
+#else
+ typedef int signed_bicremental_type_1;
+ typedef double signed_bicremental_type_2;
+ typedef boost::rational<int> signed_bicremental_type_3;
+ typedef short signed_bicremental_type_4;
+ typedef float signed_bicremental_type_5;
+#endif //BOOST_ICL_TEST_CHRONO
//DBG short list for debugging
typedef ::boost::mpl::list<
@@ -103,13 +134,21 @@
,boost::rational<boost::xint::integer>
#endif
#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<double>
+ ,boch::duration<double>
+ ,boch::time_point<Now, boch::duration<double> >
#endif
> bicremental_continuous_types;
-typedef float bicremental_continuous_type_1;
-typedef double bicremental_continuous_type_2;
-typedef boost::rational<int> bicremental_continuous_type_3;
+
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<double> bicremental_continuous_type_1;
+ typedef Now_time_double bicremental_continuous_type_2;
+ typedef Now_time_rational bicremental_continuous_type_3;
+#else
+ typedef float bicremental_continuous_type_1;
+ typedef double bicremental_continuous_type_2;
+ typedef boost::rational<int> bicremental_continuous_type_3;
+#endif // BOOST_ICL_TEST_CHRONO
typedef ::boost::mpl::list<
@@ -134,29 +173,50 @@
,boost::xint::integer
#endif
#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<unsigned short>
+ ,boch::duration<unsigned short>
+ ,Now::time_point
#endif
,boost_posix_time_ptime
- ,boost_posix_time_ptime
,boost_posix_time_duration
,boost_gregorian_date
,boost_gregorian_date_duration
,int*
> discrete_types;
-typedef int discrete_type_1;
-typedef boost_posix_time_ptime discrete_type_2;
-typedef unsigned int discrete_type_3;
-typedef short discrete_type_4;
-typedef unsigned int discrete_type_5;
+
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<int> discrete_type_1;
+ typedef duration_int_11_113s discrete_type_2;
+ typedef Now::time_point discrete_type_3;
+ typedef duration_long2_113s discrete_type_4;
+ typedef Now_time_int_11_113s discrete_type_5;
+ typedef short discrete_type_6;
+ typedef int* discrete_type_7;
+ typedef boost_posix_time_duration discrete_type_8;
+#else
+ typedef int discrete_type_1;
+ typedef boost_posix_time_ptime discrete_type_2;
+ typedef unsigned int discrete_type_3;
+ typedef short discrete_type_4;
+ typedef int* discrete_type_5;
+ typedef boost_posix_time_duration discrete_type_6;
+ typedef boost_gregorian_date discrete_type_7;
+ typedef boost_gregorian_date_duration discrete_type_8;
+#endif //BOOST_ICL_TEST_CHRONO
typedef ::boost::mpl::list<
short, int, long
> signed_discrete_types;
-typedef int signed_discrete_type_1;
-typedef short signed_discrete_type_2;
-typedef long signed_discrete_type_3;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef Now::time_point signed_discrete_type_1;
+ typedef duration_long2_113s signed_discrete_type_2;
+ typedef Now_time_int_11_113s signed_discrete_type_3;
+#else
+ typedef int signed_discrete_type_1;
+ typedef short signed_discrete_type_2;
+ typedef long signed_discrete_type_3;
+#endif //BOOST_ICL_TEST_CHRONO
typedef ::boost::mpl::list<
float, double, long double
@@ -164,15 +224,26 @@
#ifdef BOOST_ICL_TEST_XINT
,boost::rational<boost::xint::integer>
#endif
-#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<long double>
-#endif
+//JODO
+//test_interval_map_shared.hpp(1190) : error C2440: 'initializing' : cannot convert from 'long double' to 'boost::chrono::duration<Rep>'
+//#ifdef BOOST_ICL_TEST_CHRONO
+// ,boost::chrono::duration<long double>
+//#endif
> numeric_continuous_types;
-typedef double numeric_continuous_type_1;
-typedef float numeric_continuous_type_2;
-typedef boost::rational<int> numeric_continuous_type_3;
-typedef long double numeric_continuous_type_4;
+
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<double> numeric_continuous_type_1;
+ typedef Now_time_double numeric_continuous_type_2;
+ typedef Now_time_rational numeric_continuous_type_3;
+ typedef duration_rational_101_997s numeric_continuous_type_4;
+#else
+ typedef double numeric_continuous_type_1;
+ typedef float numeric_continuous_type_2;
+ typedef boost::rational<int> numeric_continuous_type_3;
+ typedef long double numeric_continuous_type_4;
+#endif //BOOST_ICL_TEST_CHRONO
+
typedef ::boost::mpl::list<
float, double, long double
@@ -181,28 +252,43 @@
,boost::rational<boost::xint::integer>
#endif
#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<double>
+ ,boch::duration<double>
+ ,boch::time_point<Now, boch::duration<double> >
#endif
,std::string
> continuous_types;
-typedef double continuous_type_1;
-typedef float continuous_type_2;
-typedef boost::rational<int> continuous_type_3;
-typedef std::string continuous_type_4;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<double> continuous_type_1;
+ typedef Now_time_double continuous_type_2;
+ typedef Now_time_rational continuous_type_3;
+ typedef std::string continuous_type_4;
+#else
+ typedef double continuous_type_1;
+ typedef float continuous_type_2;
+ typedef boost::rational<int> continuous_type_3;
+ typedef std::string continuous_type_4;
+#endif //BOOST_ICL_TEST_CHRONO
typedef ::boost::mpl::list<
- unsigned short, unsigned int
- ,unsigned long, unsigned long long
- ,short, int, long, long long
- ,float, double, long double
+ unsigned short
+ ,unsigned long
+ ,unsigned long long
+ ,short
+ ,int
+ ,long
+ ,long long
+ ,float
+ ,double
+ ,long double
,boost::rational<int>
#ifdef BOOST_ICL_TEST_XINT
,boost::xint::integer
#endif
#ifdef BOOST_ICL_TEST_CHRONO
- ,boost::chrono::duration<short>
- ,boost::chrono::duration<long double>
+ ,boch::duration<short>
+ ,boch::duration<long double>
+ ,Now::time_point
#endif
,boost_posix_time_ptime
,boost_posix_time_duration
@@ -212,11 +298,19 @@
,std::string
> ordered_types;
-typedef int ordered_type_1;
-typedef std::string ordered_type_2;
-typedef boost_posix_time_ptime ordered_type_3;
-typedef boost::rational<int> ordered_type_4;
-typedef double ordered_type_5;
+#ifdef BOOST_ICL_TEST_CHRONO
+ typedef boch::duration<int> ordered_type_1;
+ typedef boch::duration<double> ordered_type_2;
+ typedef Now::time_point ordered_type_3;
+ typedef Now_time_double ordered_type_4;
+ typedef Now_time_rational ordered_type_5;
+#else
+ typedef int ordered_type_1;
+ typedef std::string ordered_type_2;
+ typedef boost_posix_time_ptime ordered_type_3;
+ typedef boost::rational<int> ordered_type_4;
+ typedef double ordered_type_5;
+#endif //BOOST_ICL_TEST_CHRONO
#endif