[Boost-commit] svn:boost r70722 - in trunk: boost/chrono boost/icl/concept boost/icl/type_traits libs/icl/test libs/icl/test/test_casual_

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