Subject: [Boost-commit] svn:boost r65627 - in sandbox/chrono/libs/ratio/example: . type_traits type_traits/detail
From: vicente.botet_at_[hidden]
Date: 2010-09-27 08:17:39
Author: viboes
Date: 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
New Revision: 65627
URL: http://svn.boost.org/trac/boost/changeset/65627
Log:
Ratio. remove dependency to common_type file
Added:
sandbox/chrono/libs/ratio/example/type_traits/
sandbox/chrono/libs/ratio/example/type_traits/add_rvalue_reference.hpp (contents, props changed)
sandbox/chrono/libs/ratio/example/type_traits/common_type.hpp (contents, props changed)
sandbox/chrono/libs/ratio/example/type_traits/declval.hpp (contents, props changed)
sandbox/chrono/libs/ratio/example/type_traits/detail/
sandbox/chrono/libs/ratio/example/type_traits/detail/common_type.hpp (contents, props changed)
Text files modified:
sandbox/chrono/libs/ratio/example/config.hpp | 84 ++++++++++++++--------------
sandbox/chrono/libs/ratio/example/duration.hpp | 117 ++++++++++++++++++++-------------------
sandbox/chrono/libs/ratio/example/si_physics.cpp | 14 ++--
sandbox/chrono/libs/ratio/example/static_assert.hpp | 16 ++--
4 files changed, 116 insertions(+), 115 deletions(-)
Modified: sandbox/chrono/libs/ratio/example/config.hpp
==============================================================================
--- sandbox/chrono/libs/ratio/example/config.hpp (original)
+++ sandbox/chrono/libs/ratio/example/config.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -8,55 +8,55 @@
// See http://www.boost.org/libs/chrono for documentation.
-#ifndef BOOST_CHRONO_CONFIG_HPP
-#define BOOST_CHRONO_CONFIG_HPP
+#ifndef BOOST_EX_CHRONO_CONFIG_HPP
+#define BOOST_EX_CHRONO_CONFIG_HPP
#include <boost/config.hpp>
-// BOOST_CHRONO_POSIX_API, BOOST_CHRONO_MAC_API, or BOOST_CHRONO_WINDOWS_API
+// BOOST_EX_CHRONO_POSIX_API, BOOST_EX_CHRONO_MAC_API, or BOOST_EX_CHRONO_WINDOWS_API
// can be defined by the user to specify which API should be used
-#if defined(BOOST_CHRONO_WINDOWS_API)
+#if defined(BOOST_EX_CHRONO_WINDOWS_API)
# warning Boost.Chrono will use the Windows API
-#elif defined(BOOST_CHRONO_MAC_API)
+#elif defined(BOOST_EX_CHRONO_MAC_API)
# warning Boost.Chrono will use the Mac API
-#elif defined(BOOST_CHRONO_POSIX_API)
+#elif defined(BOOST_EX_CHRONO_POSIX_API)
# warning Boost.Chrono will use the POSIX API
#endif
-# if defined( BOOST_CHRONO_WINDOWS_API ) && defined( BOOST_CHRONO_POSIX_API )
-# error both BOOST_CHRONO_WINDOWS_API and BOOST_CHRONO_POSIX_API are defined
-# elif defined( BOOST_CHRONO_WINDOWS_API ) && defined( BOOST_CHRONO_MAC_API )
-# error both BOOST_CHRONO_WINDOWS_API and BOOST_CHRONO_MAC_API are defined
-# elif defined( BOOST_CHRONO_MAC_API ) && defined( BOOST_CHRONO_POSIX_API )
-# error both BOOST_CHRONO_MAC_API and BOOST_CHRONO_POSIX_API are defined
-# elif !defined( BOOST_CHRONO_WINDOWS_API ) && !defined( BOOST_CHRONO_MAC_API ) && !defined( BOOST_CHRONO_POSIX_API )
+# if defined( BOOST_EX_CHRONO_WINDOWS_API ) && defined( BOOST_EX_CHRONO_POSIX_API )
+# error both BOOST_EX_CHRONO_WINDOWS_API and BOOST_EX_CHRONO_POSIX_API are defined
+# elif defined( BOOST_EX_CHRONO_WINDOWS_API ) && defined( BOOST_EX_CHRONO_MAC_API )
+# error both BOOST_EX_CHRONO_WINDOWS_API and BOOST_EX_CHRONO_MAC_API are defined
+# elif defined( BOOST_EX_CHRONO_MAC_API ) && defined( BOOST_EX_CHRONO_POSIX_API )
+# error both BOOST_EX_CHRONO_MAC_API and BOOST_EX_CHRONO_POSIX_API are defined
+# elif !defined( BOOST_EX_CHRONO_WINDOWS_API ) && !defined( BOOST_EX_CHRONO_MAC_API ) && !defined( BOOST_EX_CHRONO_POSIX_API )
# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
-# define BOOST_CHRONO_WINDOWS_API
-# define BOOST_CHRONO_HAS_CLOCK_MONOTONIC
-# define BOOST_CHRONO_HAS_THREAD_CLOCK
-# define BOOST_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
+# define BOOST_EX_CHRONO_WINDOWS_API
+# define BOOST_EX_CHRONO_HAS_CLOCK_MONOTONIC
+# define BOOST_EX_CHRONO_HAS_THREAD_CLOCK
+# define BOOST_EX_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
# elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
-# define BOOST_CHRONO_MAC_API
-# define BOOST_CHRONO_HAS_CLOCK_MONOTONIC
-# define BOOST_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
+# define BOOST_EX_CHRONO_MAC_API
+# define BOOST_EX_CHRONO_HAS_CLOCK_MONOTONIC
+# define BOOST_EX_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
# else
-# define BOOST_CHRONO_POSIX_API
+# define BOOST_EX_CHRONO_POSIX_API
# endif
# endif
-# if defined( BOOST_CHRONO_POSIX_API )
+# if defined( BOOST_EX_CHRONO_POSIX_API )
# include <time.h> //to check for CLOCK_REALTIME and CLOCK_MONOTONIC and _POSIX_THREAD_CPUTIME
# if defined(CLOCK_REALTIME)
# if defined(CLOCK_MONOTONIC)
-# define BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+# define BOOST_EX_CHRONO_HAS_CLOCK_MONOTONIC
# endif
# else
# error <time.h> does not supply CLOCK_REALTIME
# endif
# if defined(_POSIX_THREAD_CPUTIME)
-# define BOOST_CHRONO_HAS_THREAD_CLOCK
-# define BOOST_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
+# define BOOST_EX_CHRONO_HAS_THREAD_CLOCK
+# define BOOST_EX_CHRONO_THREAD_CLOCK_IS_MONOTONIC true
# endif
# endif
@@ -64,44 +64,44 @@
// enable dynamic linking on Windows ---------------------------------------//
-//# if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CHRONO_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
+//# if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_EX_CHRONO_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
//# error Dynamic linking Boost.System does not work for Borland; use static linking instead
//# endif
#ifdef BOOST_HAS_DECLSPEC // defined by boost.config
// we need to import/export our code only if the user has specifically
// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
-// libraries to be dynamically linked, or BOOST_CHRONO_DYN_LINK
+// libraries to be dynamically linked, or BOOST_EX_CHRONO_DYN_LINK
// if they want just this one to be dynamically liked:
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CHRONO_DYN_LINK)
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_EX_CHRONO_DYN_LINK)
// export if this is our own source, otherwise import:
-#ifdef BOOST_CHRONO_SOURCE
-# define BOOST_CHRONO_DECL __declspec(dllexport)
+#ifdef BOOST_EX_CHRONO_SOURCE
+# define BOOST_EX_CHRONO_DECL __declspec(dllexport)
#else
-# define BOOST_CHRONO_DECL __declspec(dllimport)
-#endif // BOOST_CHRONO_SOURCE
+# define BOOST_EX_CHRONO_DECL __declspec(dllimport)
+#endif // BOOST_EX_CHRONO_SOURCE
#endif // DYN_LINK
#endif // BOOST_HAS_DECLSPEC
//
-// if BOOST_CHRONO_DECL isn't defined yet define it now:
-#ifndef BOOST_CHRONO_DECL
-#define BOOST_CHRONO_DECL
+// if BOOST_EX_CHRONO_DECL isn't defined yet define it now:
+#ifndef BOOST_EX_CHRONO_DECL
+#define BOOST_EX_CHRONO_DECL
#endif
// define constexpr related macros ------------------------------//
//~ #include <boost/config.hpp>
#if defined(BOOST_NO_CONSTEXPR)
-#define BOOST_CHRONO_CONSTEXPR
-#define BOOST_CHRONO_CONST_REF const&
+#define BOOST_EX_CHRONO_CONSTEXPR
+#define BOOST_EX_CHRONO_CONST_REF const&
#else
-#define BOOST_CHRONO_CONSTEXPR constexpr
-#define BOOST_CHRONO_CONST_REF
+#define BOOST_EX_CHRONO_CONSTEXPR constexpr
+#define BOOST_EX_CHRONO_CONST_REF
#endif
// enable automatic library variant selection ------------------------------//
-#if !defined(BOOST_CHRONO_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_CHRONO_NO_LIB)
+#if !defined(BOOST_EX_CHRONO_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_EX_CHRONO_NO_LIB)
//
// Set the name of our library; this will get undef'ed by auto_link.hpp
// once it's done with it:
@@ -110,7 +110,7 @@
//
// If we're importing code from a dll, then tell auto_link.hpp about it:
//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CHRONO_DYN_LINK)
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_EX_CHRONO_DYN_LINK)
# define BOOST_DYN_LINK
#endif
//
@@ -119,5 +119,5 @@
#include <boost/config/auto_link.hpp>
#endif // auto-linking disabled
-#endif // BOOST_CHRONO_CONFIG_HPP
+#endif // BOOST_EX_CHRONO_CONFIG_HPP
Modified: sandbox/chrono/libs/ratio/example/duration.hpp
==============================================================================
--- sandbox/chrono/libs/ratio/example/duration.hpp (original)
+++ sandbox/chrono/libs/ratio/example/duration.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -27,8 +27,8 @@
*/
-#ifndef BOOST_CHRONO_DURATION_HPP
-#define BOOST_CHRONO_DURATION_HPP
+#ifndef BOOST_EX_CHRONO_DURATION_HPP
+#define BOOST_EX_CHRONO_DURATION_HPP
#include "config.hpp"
#include "static_assert.hpp"
@@ -41,7 +41,7 @@
#include <boost/mpl/logical.hpp>
#include <boost/ratio.hpp>
-#include <boost/type_traits/common_type.hpp>
+#include "type_traits/common_type.hpp"
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/type_traits/is_unsigned.hpp>
@@ -51,11 +51,11 @@
#include <boost/detail/workaround.hpp>
#include <boost/integer_traits.hpp>
-#if !defined(BOOST_NO_STATIC_ASSERT) || !defined(BOOST_CHRONO_USES_MPL_ASSERT)
-#define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION "A duration representation can not be a duration"
-#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO "Second template parameter of duration must be a boost::ratio"
-#define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE "duration period must be positive"
-#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION "Second template parameter of time_point must be a boost::chrono::duration"
+#if !defined(BOOST_NO_STATIC_ASSERT) || !defined(BOOST_EX_CHRONO_USES_MPL_ASSERT)
+#define BOOST_EX_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION "A duration representation can not be a duration"
+#define BOOST_EX_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO "Second template parameter of duration must be a boost::ratio"
+#define BOOST_EX_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE "duration period must be positive"
+#define BOOST_EX_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_EX_CHRONO_DURATION "Second template parameter of time_point must be a boost_ex::chrono::duration"
#endif
@@ -66,7 +66,9 @@
// //
//----------------------------------------------------------------------------//
-namespace boost {
+namespace boost_ex {
+ using boost::ratio;
+
namespace chrono {
template <class Rep, class Period = ratio<1> >
@@ -247,9 +249,9 @@
// ToDuration duration_cast(const duration<Rep, Period>& d);
// convenience typedefs
- typedef duration<boost::int_least64_t, nano> nanoseconds; // at least 64 bits needed
- typedef duration<boost::int_least64_t, micro> microseconds; // at least 55 bits needed
- typedef duration<boost::int_least64_t, milli> milliseconds; // at least 45 bits needed
+ typedef duration<boost::int_least64_t, boost::nano> nanoseconds; // at least 64 bits needed
+ typedef duration<boost::int_least64_t, boost::micro> microseconds; // at least 55 bits needed
+ typedef duration<boost::int_least64_t, boost::milli> milliseconds; // at least 45 bits needed
typedef duration<boost::int_least64_t> seconds; // at least 35 bits needed
typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
typedef duration<boost::int_least32_t, ratio<3600> > hours; // at least 23 bits needed
@@ -273,7 +275,7 @@
// the use of common_type ensures that the most logical "intermediate"
// representation is used.
template <class FromDuration, class ToDuration,
- class Period = typename ratio_divide<typename FromDuration::period,
+ class Period = typename boost::ratio_divide<typename FromDuration::period,
typename ToDuration::period>::type,
bool = Period::num == 1,
bool = Period::den == 1>
@@ -374,7 +376,7 @@
//----------------------------------------------------------------------------//
namespace detail {
- template <class T, bool = is_arithmetic<T>::value>
+ template <class T, bool = boost::is_arithmetic<T>::value>
struct chrono_numeric_limits {
static T lowest() throw() {return (std::numeric_limits<T>::min) ();}
};
@@ -400,16 +402,16 @@
};
template <class T>
- struct numeric_limits : chrono_numeric_limits<typename remove_cv<T>::type> {};
+ struct numeric_limits : chrono_numeric_limits<typename boost::remove_cv<T>::type> {};
}
template <class Rep>
struct duration_values
{
- static BOOST_CHRONO_CONSTEXPR Rep zero() {return Rep(0);}
- static BOOST_CHRONO_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (std::numeric_limits<Rep>::max)();}
+ static Rep zero() {return Rep(0);}
+ static Rep max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (std::numeric_limits<Rep>::max)();}
- static BOOST_CHRONO_CONSTEXPR Rep min BOOST_PREVENT_MACRO_SUBSTITUTION () {return detail::numeric_limits<Rep>::lowest();}
+ static Rep min BOOST_PREVENT_MACRO_SUBSTITUTION () {return detail::numeric_limits<Rep>::lowest();}
};
} // namespace chrono
@@ -439,9 +441,9 @@
template <class Rep, class Period>
class duration
{
- BOOST_CHRONO_STATIC_ASSERT(!boost::chrono::detail::is_duration<Rep>::value, BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION, ());
- BOOST_CHRONO_STATIC_ASSERT(boost::detail::is_ratio<Period>::value, BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO, ());
- BOOST_CHRONO_STATIC_ASSERT(Period::num>0, BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE, ());
+ BOOST_EX_CHRONO_STATIC_ASSERT(!boost_ex::chrono::detail::is_duration<Rep>::value, BOOST_EX_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION, ());
+ BOOST_EX_CHRONO_STATIC_ASSERT(boost::detail::is_ratio<Period>::value, BOOST_EX_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO, ());
+ BOOST_EX_CHRONO_STATIC_ASSERT(Period::num>0, BOOST_EX_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE, ());
public:
typedef Rep rep;
typedef Period period;
@@ -449,17 +451,17 @@
rep rep_;
public:
- BOOST_CHRONO_CONSTEXPR duration() { } // = default;
+ duration() { } // = default;
template <class Rep2>
- BOOST_CHRONO_CONSTEXPR explicit duration(const Rep2& r,
+ explicit duration(const Rep2& r,
typename boost::enable_if <
- mpl::and_ <
+ boost::mpl::and_ <
boost::is_convertible<Rep2, rep>,
- mpl::or_ <
+ boost::mpl::or_ <
treat_as_floating_point<rep>,
- mpl::and_ <
- mpl::not_ < treat_as_floating_point<rep> >,
- mpl::not_ < treat_as_floating_point<Rep2> >
+ boost::mpl::and_ <
+ boost::mpl::not_ < treat_as_floating_point<rep> >,
+ boost::mpl::not_ < treat_as_floating_point<Rep2> >
>
>
>
@@ -475,13 +477,13 @@
// conversions
template <class Rep2, class Period2>
- BOOST_CHRONO_CONSTEXPR duration(const duration<Rep2, Period2>& d,
+ duration(const duration<Rep2, Period2>& d,
typename boost::enable_if <
- mpl::or_ <
+ boost::mpl::or_ <
treat_as_floating_point<rep>,
- mpl::and_ <
- mpl::bool_ < ratio_divide<Period2, period>::type::den == 1>,
- mpl::not_ < treat_as_floating_point<Rep2> >
+ boost::mpl::and_ <
+ boost::mpl::bool_ < boost::ratio_divide<Period2, period>::type::den == 1>,
+ boost::mpl::not_ < treat_as_floating_point<Rep2> >
>
>
>::type* = 0)
@@ -498,7 +500,7 @@
// observer
- BOOST_CHRONO_CONSTEXPR rep count() const {return rep_;}
+ rep count() const {return rep_;}
// arithmetic
@@ -518,9 +520,9 @@
duration& operator%=(const duration& rhs) {rep_ %= rhs.count(); return *this;};
// 20.9.3.4 duration special values [time.duration.special]
- static BOOST_CHRONO_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
- static BOOST_CHRONO_CONSTEXPR duration min BOOST_PREVENT_MACRO_SUBSTITUTION () {return duration((duration_values<rep>::min)());}
- static BOOST_CHRONO_CONSTEXPR duration max BOOST_PREVENT_MACRO_SUBSTITUTION () {return duration((duration_values<rep>::max)());}
+ static duration zero() {return duration(duration_values<rep>::zero());}
+ static duration min BOOST_PREVENT_MACRO_SUBSTITUTION () {return duration((duration_values<rep>::min)());}
+ static duration max BOOST_PREVENT_MACRO_SUBSTITUTION () {return duration((duration_values<rep>::max)());}
};
//----------------------------------------------------------------------------//
@@ -558,7 +560,7 @@
template <class Rep1, class Period, class Rep2>
inline
typename boost::enable_if <
- mpl::and_ <
+ boost::mpl::and_ <
boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
>,
@@ -575,7 +577,7 @@
template <class Rep1, class Period, class Rep2>
inline
typename boost::enable_if <
- mpl::and_ <
+ boost::mpl::and_ <
boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
>,
@@ -590,8 +592,8 @@
template <class Rep1, class Period, class Rep2>
inline
- typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
- typename boost::chrono::detail::duration_divide_result<duration<Rep1, Period>, Rep2>::type
+ typename boost::disable_if <boost_ex::chrono::detail::is_duration<Rep2>,
+ typename boost_ex::chrono::detail::duration_divide_result<duration<Rep1, Period>, Rep2>::type
>::type
operator/(const duration<Rep1, Period>& d, const Rep2& s)
{
@@ -613,8 +615,8 @@
template <class Rep1, class Rep2, class Period>
inline
- typename boost::disable_if <boost::chrono::detail::is_duration<Rep1>,
- typename boost::chrono::detail::duration_divide_result2<Rep1, duration<Rep2, Period> >::type
+ typename boost::disable_if <boost_ex::chrono::detail::is_duration<Rep1>,
+ typename boost_ex::chrono::detail::duration_divide_result2<Rep1, duration<Rep2, Period> >::type
>::type
operator/(const Rep1& s, const duration<Rep2, Period>& d)
{
@@ -627,8 +629,8 @@
// Duration %
template <class Rep1, class Period, class Rep2>
- typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
- typename boost::chrono::detail::duration_modulo_result<duration<Rep1, Period>, Rep2>::type
+ typename boost::disable_if <boost_ex::chrono::detail::is_duration<Rep2>,
+ typename boost_ex::chrono::detail::duration_modulo_result<duration<Rep1, Period>, Rep2>::type
>::type
operator%(const duration<Rep1, Period>& d, const Rep2& s) {
typedef typename common_type<Rep1, Rep2>::type CR;
@@ -697,7 +699,7 @@
bool
operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
- return boost::chrono::detail::duration_eq<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
+ return boost_ex::chrono::detail::duration_eq<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
}
// Duration !=
@@ -717,7 +719,7 @@
bool
operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
- return boost::chrono::detail::duration_lt<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
+ return boost_ex::chrono::detail::duration_lt<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
}
// Duration >
@@ -757,10 +759,10 @@
// Compile-time select the most efficient algorithm for the conversion...
template <class ToDuration, class Rep, class Period>
inline
- typename boost::enable_if <boost::chrono::detail::is_duration<ToDuration>, ToDuration>::type
+ typename boost::enable_if <boost_ex::chrono::detail::is_duration<ToDuration>, ToDuration>::type
duration_cast(const duration<Rep, Period>& fd)
{
- return boost::chrono::detail::duration_cast<duration<Rep, Period>, ToDuration>()(fd);
+ return boost_ex::chrono::detail::duration_cast<duration<Rep, Period>, ToDuration>()(fd);
}
@@ -773,20 +775,19 @@
// see comment above in section 20.9.3 Class template duration [time.duration]
template <class Rep, class Period>
template <class Rep2, class Period2>
- BOOST_CHRONO_CONSTEXPR duration<Rep, Period>::duration(const duration<Rep2, Period2>& d,
+ duration<Rep, Period>::duration(const duration<Rep2, Period2>& d,
typename boost::enable_if <
- mpl::or_ <
+ boost::mpl::or_ <
treat_as_floating_point<rep>,
- mpl::and_ <
- mpl::bool_ <ratio_divide<Period2, period>::type::den == 1>,
- mpl::not_ <treat_as_floating_point<Rep2> >
+ boost::mpl::and_ <
+ boost::mpl::bool_ <boost::ratio_divide<Period2, period>::type::den == 1>,
+ boost::mpl::not_ <treat_as_floating_point<Rep2> >
>
>
>::type*)
: rep_(duration_cast<duration>(d).count()) {}
#endif
-} // namespace chrono
-} // namespace boost
-
-#endif // BOOST_CHRONO_DURATION_HPP
+}
+}
+#endif // BOOST_EX_CHRONO_DURATION_HPP
Modified: sandbox/chrono/libs/ratio/example/si_physics.cpp
==============================================================================
--- sandbox/chrono/libs/ratio/example/si_physics.cpp (original)
+++ sandbox/chrono/libs/ratio/example/si_physics.cpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -12,10 +12,10 @@
namespace User1
{
-// Example type-safe "physics" code interoperating with std::chrono::duration types
+// Example type-safe "physics" code interoperating with chrono::duration types
// and taking advantage of the std::ratio infrastructure and design philosophy.
-// length - mimics std::chrono::duration except restricts representation to double.
+// length - mimics chrono::duration except restricts representation to double.
// Uses boost::ratio facilities for length units conversions.
template <class Ratio>
@@ -62,11 +62,11 @@
typedef length<boost::ratio_multiply<boost::ratio<5280>, foot::ratio>::type> mile; // 5280 feet
// Need a floating point definition of seconds
-typedef boost::chrono::duration<double> seconds; // unity
+typedef boost_ex::chrono::duration<double> seconds; // unity
// Demo of (scientific) support for sub-nanosecond resolutions
-typedef boost::chrono::duration<double, boost::pico> picosecond; // 10^-12 seconds
-typedef boost::chrono::duration<double, boost::femto> femtosecond; // 10^-15 seconds
-typedef boost::chrono::duration<double, boost::atto> attosecond; // 10^-18 seconds
+typedef boost_ex::chrono::duration<double, boost::pico> picosecond; // 10^-12 seconds
+typedef boost_ex::chrono::duration<double, boost::femto> femtosecond; // 10^-15 seconds
+typedef boost_ex::chrono::duration<double, boost::atto> attosecond; // 10^-18 seconds
// A very brief proof-of-concept for SIUnits-like library
// Hard-wired to floating point seconds and meters, but accepts other units (shown in testUser1())
@@ -196,7 +196,7 @@
std::cout << "* testUser1 *\n";
std::cout << "*************\n";
User1::Distance d( User1::mile(110) );
- User1::Time t(( boost::chrono::hours(2) ));
+ User1::Time t(( boost_ex::chrono::hours(2) ));
//typedef User1::quantity<boost::ratio_subtract<User1::Distance::time_dim, User1::Time::time_dim >::type,
// boost::ratio_subtract<User1::Distance::distance_dim, User1::Time::distance_dim >::type > R;
Modified: sandbox/chrono/libs/ratio/example/static_assert.hpp
==============================================================================
--- sandbox/chrono/libs/ratio/example/static_assert.hpp (original)
+++ sandbox/chrono/libs/ratio/example/static_assert.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -6,25 +6,25 @@
// See http://www.boost.org/LICENSE_1_0.txt
-#ifndef BOOST_CHRONO_DETAIL_STATIC_ASSERT_HPP
-#define BOOST_CHRONO_DETAIL_STATIC_ASSERT_HPP
+#ifndef BOOST_EX_CHRONO_DETAIL_STATIC_ASSERT_HPP
+#define BOOST_EX_CHRONO_DETAIL_STATIC_ASSERT_HPP
#include "config.hpp"
#ifndef BOOST_NO_STATIC_ASSERT
-#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
#elif defined(BOOST_CHRONO_USES_STATIC_ASSERT)
#include <boost/static_assert.hpp>
-#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
#elif defined(BOOST_CHRONO_USES_MPL_ASSERT)
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
-#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) \
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) \
BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
#else
//~ #elif defined(BOOST_CHRONO_USES_ARRAY_ASSERT)
-#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_JOIN(boost_chrono_test_,__LINE__)[(CND)?1:-1]
-//~ #define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES)
+#define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_JOIN(boost_chrono_test_,__LINE__)[(CND)?1:-1]
+//~ #define BOOST_EX_CHRONO_STATIC_ASSERT(CND, MSG, TYPES)
#endif
-#endif // BOOST_CHRONO_DETAIL_STATIC_ASSERT_HPP
+#endif // BOOST_EX_CHRONO_DETAIL_STATIC_ASSERT_HPP
Added: sandbox/chrono/libs/ratio/example/type_traits/add_rvalue_reference.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/ratio/example/type_traits/add_rvalue_reference.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -0,0 +1,67 @@
+// add_rvalue_reference.hpp ---------------------------------------------------------//
+
+// Copyright 2010 Vicente J. Botet Escriba
+
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+//----------------------------------------------------------------------------//
+// //
+// C++03 implementation of //
+// 20.7.6.2 Reference modifications [meta.trans.ref] //
+// Written by Vicente J. Botet Escriba //
+// //
+// If T names an object or function type then the member typedef type
+// shall name T&&; otherwise, type shall name T. [ Note: This rule reflects
+// the semantics of reference collapsing. For example, when a type T names
+// a type T1&, the type add_rvalue_reference<T>::type is not an rvalue
+// reference. —end note ]
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+namespace type_traits_detail {
+
+ template <typename T, bool b>
+ struct add_rvalue_reference_helper
+ { typedef T type; };
+
+ template <typename T>
+ struct add_rvalue_reference_helper<T, true>
+ {
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+ typedef T&& type;
+#else
+ typedef T type;
+#endif
+ };
+
+ template <typename T>
+ struct add_rvalue_reference_imp
+ {
+ typedef typename boost_ex::type_traits_detail::add_rvalue_reference_helper
+ <T, (!boost::is_void<T>::value && !boost::is_reference<T>::value) >::type type;
+ };
+
+}
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_rvalue_reference,T,typename boost_ex::type_traits_detail::add_rvalue_reference_imp<T>::type)
+
+} // namespace boost_ex
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_EX_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
Added: sandbox/chrono/libs/ratio/example/type_traits/common_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/ratio/example/type_traits/common_type.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -0,0 +1,151 @@
+// common_type.hpp ---------------------------------------------------------//
+
+// Copyright 2008 Howard Hinnant
+// Copyright 2008 Beman Dawes
+
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_COMMON_TYPE_HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_COMMON_TYPE_HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+#if defined(BOOST_NO_VARIADIC_TEMPLATES)
+#define BOOST_EX_COMMON_TYPE_ARITY 3
+#endif
+
+//----------------------------------------------------------------------------//
+#if defined(BOOST_NO_DECLTYPE) && !defined(BOOST_EX_COMMON_TYPE_DONT_USE_TYPEOF)
+#define BOOST_TYPEOF_SILENT
+#include <boost/typeof/typeof.hpp> // boost wonders never cease!
+#endif
+
+//----------------------------------------------------------------------------//
+#ifndef BOOST_NO_STATIC_ASSERT
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
+#elif defined(BOOST_EX_COMMON_TYPE_USES_STATIC_ASSERT)
+#include <boost/static_assert.hpp>
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
+#elif defined(BOOST_EX_COMMON_TYPE_USES_MPL_ASSERT)
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) \
+ BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
+#else
+//~ #elif defined(BOOST_EX_COMMON_TYPE_USES_ARRAY_ASSERT)
+#define BOOST_EX_COMMON_TYPE_CONCAT(A,B) A##B
+#define BOOST_EX_COMMON_TYPE_NAME(A,B) BOOST_EX_COMMON_TYPE_CONCAT(A,B)
+#define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_EX_COMMON_TYPE_NAME(__boost_common_type_test_,__LINE__)[(CND)?1:-1]
+//~ #define BOOST_EX_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES)
+#endif
+
+#if !defined(BOOST_NO_STATIC_ASSERT) || !defined(BOOST_EX_COMMON_TYPE_USES_MPL_ASSERT)
+#define BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE "must be complete type"
+#endif
+
+#if defined(BOOST_NO_DECLTYPE) && defined(BOOST_EX_COMMON_TYPE_DONT_USE_TYPEOF)
+#include "detail/common_type.hpp"
+#include <boost/type_traits/remove_cv.hpp>
+#endif
+#include <boost/mpl/if.hpp>
+#include "declval.hpp"
+
+//----------------------------------------------------------------------------//
+// //
+// C++03 implementation of //
+// 20.6.7 Other transformations [meta.trans.other] //
+// Written by Howard Hinnant //
+// Adapted for Boost by Beman Dawes, Vicente Botet and Jeffrey Hellrung //
+// //
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+// prototype
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+ template<typename... T>
+ struct common_type;
+#else // or no specialization
+ template <class T, class U = void, class V = void>
+ struct common_type
+ {
+ public:
+ typedef typename common_type<typename common_type<T, U>::type, V>::type type;
+ };
+#endif
+
+
+// 1 arg
+ template<typename T>
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+ struct common_type<T>
+#else
+ struct common_type<T, void, void>
+
+#endif
+ {
+ BOOST_EX_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
+ public:
+ typedef T type;
+ };
+
+// 2 args
+namespace type_traits_detail {
+
+ template <class T, class U>
+ struct common_type_2
+ {
+ private:
+ BOOST_EX_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
+ BOOST_EX_COMMON_TYPE_STATIC_ASSERT(sizeof(U) > 0, BOOST_EX_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (U));
+ static bool declval_bool(); // workaround gcc bug; not required by std
+ static typename add_rvalue_reference<T>::type declval_T(); // workaround gcc bug; not required by std
+ static typename add_rvalue_reference<U>::type declval_U(); // workaround gcc bug; not required by std
+
+#if !defined(BOOST_NO_DECLTYPE)
+ public:
+ typedef decltype(declval<bool>() ? declval<T>() : declval<U>()) type;
+#elif defined(BOOST_EX_COMMON_TYPE_DONT_USE_TYPEOF)
+ public:
+ typedef typename detail_type_traits_common_type::common_type_impl<
+ typename remove_cv<T>::type,
+ typename remove_cv<U>::type
+ >::type type;
+#else
+ public:
+ //~ typedef BOOST_TYPEOF_TPL(declval_bool() ? declval_T() : declval_U()) type;
+ typedef BOOST_TYPEOF_TPL(declval<bool>() ? declval<T>() : declval<U>()) type;
+#endif
+ };
+
+ template <class T>
+ struct common_type_2<T, T>
+ {
+ typedef T type;
+ };
+ }
+
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+ template <class T, class U>
+ struct common_type<T, U>
+#else
+ template <class T, class U>
+ struct common_type<T, U, void>
+#endif
+ : type_traits_detail::common_type_2<T,U>
+ { };
+
+
+// 3 or more args
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
+ template<typename T, typename U, typename... V>
+ struct common_type<T, U, V...> {
+ public:
+ typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
+ };
+#endif
+} // namespace boost_ex
+
+#endif // BOOST_TYPE_TRAITS_EXT_COMMON_TYPE_HPP
Added: sandbox/chrono/libs/ratio/example/type_traits/declval.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/ratio/example/type_traits/declval.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -0,0 +1,44 @@
+// common_type.hpp ---------------------------------------------------------//
+
+// Copyright 2010 Vicente J. Botet Escriba
+
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_DECLVAL__HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_DECLVAL__HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+
+#include "add_rvalue_reference.hpp"
+
+//----------------------------------------------------------------------------//
+// //
+// C++03 implementation of //
+// Written by Vicente J. Botet Escriba //
+//~ 20.3.4 Function template declval [declval]
+//~ 1 The library provides the function template declval to simplify the definition of expressions which occur as
+//~ unevaluated operands.
+//~ 2 Remarks: If this function is used, the program is ill-formed.
+//~ 3 Remarks: The template parameter T of declval may be an incomplete type.
+//~ [ Example:
+
+//~ template <class To, class From>
+//~ decltype(static_cast<To>(declval<From>())) convert(From&&);
+
+//~ declares a function template convert which only participats in overloading if the type From can be
+//~ explicitly converted to type To. For another example see class template common_type (20.7.6.6). —end
+//~ example ]
+// //
+//----------------------------------------------------------------------------//
+
+namespace boost_ex {
+
+ template <typename T>
+ typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
+
+} // namespace boost
+
+#endif // BOOST_EX_TYPE_TRAITS_EXT_DECLVAL__HPP
Added: sandbox/chrono/libs/ratio/example/type_traits/detail/common_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/ratio/example/type_traits/detail/common_type.hpp 2010-09-27 08:17:37 EDT (Mon, 27 Sep 2010)
@@ -0,0 +1,316 @@
+/*******************************************************************************
+ * boost/type_traits/detail/common_type.hpp
+ *
+ * Copyright 2010, Jeffrey Hellrung.
+ * Distributed under the Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * struct boost::common_type<T,U>
+ *
+ * common_type<T,U>::type is the type of the expression
+ * b() ? x() : y()
+ * where b() returns a bool, x() has return type T, and y() has return type U.
+ * See
+ * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm#common_type
+ *
+ * Note that this evaluates to void if one or both of T and U is void.
+ ******************************************************************************/
+
+#ifndef BOOST_EX_TYPE_TRAITS_EXT_DETAIL_COMMON_TYPE_HPP
+#define BOOST_EX_TYPE_TRAITS_EXT_DETAIL_COMMON_TYPE_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/inserter.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/vector/vector0.hpp>
+#include <boost/mpl/vector/vector10.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/declval.hpp>
+
+namespace boost_ex
+{
+
+namespace detail_type_traits_common_type
+{
+
+/*******************************************************************************
+ * struct propagate_cv< From, To >
+ *
+ * This metafunction propagates cv-qualifiers on type From to type To.
+ ******************************************************************************/
+
+template< class From, class To >
+struct propagate_cv
+{ typedef To type; };
+template< class From, class To >
+struct propagate_cv< const From, To >
+{ typedef To const type; };
+template< class From, class To >
+struct propagate_cv< volatile From, To >
+{ typedef To volatile type; };
+template< class From, class To >
+struct propagate_cv< const volatile From, To >
+{ typedef To const volatile type; };
+
+/*******************************************************************************
+ * struct is_signable_integral<T>
+ *
+ * This metafunction determines if T is an integral type which can be made
+ * signed or unsigned.
+ ******************************************************************************/
+
+template< class T >
+struct is_signable_integral
+ : mpl::or_< is_integral<T>, is_enum<T> >
+{ };
+template<>
+struct is_signable_integral< bool >
+ : false_type
+{ };
+
+/*******************************************************************************
+ * struct sizeof_t<N>
+ * typedef ... yes_type
+ * typedef ... no_type
+ *
+ * These types are integral players in the use of the "sizeof trick", i.e., we
+ * can distinguish overload selection by inspecting the size of the return type
+ * of the overload.
+ ******************************************************************************/
+
+template< std::size_t N > struct sizeof_t { char _dummy[N]; };
+typedef sizeof_t<1> yes_type;
+typedef sizeof_t<2> no_type;
+BOOST_MPL_ASSERT_RELATION( sizeof( yes_type ), ==, 1 );
+BOOST_MPL_ASSERT_RELATION( sizeof( no_type ), ==, 2 );
+
+/*******************************************************************************
+ * rvalue_test(T&) -> no_type
+ * rvalue_test(...) -> yes_type
+ *
+ * These overloads are used to determine the rvalue-ness of an expression.
+ ******************************************************************************/
+
+template< class T > no_type rvalue_test(T&);
+yes_type rvalue_test(...);
+
+/*******************************************************************************
+ * struct conversion_test_overloads< Sequence >
+ *
+ * This struct has multiple overloads of the static member function apply, each
+ * one taking a single parameter of a type within the Boost.MPL sequence
+ * Sequence. Each such apply overload has a return type with sizeof equal to
+ * one plus the index of the parameter type within Sequence. Thus, we can
+ * deduce the type T of an expression as long as we can generate a finite set of
+ * candidate types containing T via these apply overloads and the "sizeof
+ * trick".
+ ******************************************************************************/
+
+template< class First, class Last, std::size_t Index >
+struct conversion_test_overloads_iterate
+ : conversion_test_overloads_iterate<
+ typename mpl::next< First >::type, Last, Index + 1
+ >
+{
+ using conversion_test_overloads_iterate<
+ typename mpl::next< First >::type, Last, Index + 1
+ >::apply;
+ static sizeof_t< Index + 1 >
+ apply(typename mpl::deref< First >::type);
+};
+
+template< class Last, std::size_t Index >
+struct conversion_test_overloads_iterate< Last, Last, Index >
+{ static sizeof_t< Index + 1 > apply(...); };
+
+template< class Sequence >
+struct conversion_test_overloads
+ : conversion_test_overloads_iterate<
+ typename mpl::begin< Sequence >::type,
+ typename mpl::end< Sequence >::type,
+ 0
+ >
+{ };
+
+/*******************************************************************************
+ * struct select< Sequence, Index >
+ *
+ * select is synonymous with mpl::at_c unless Index equals the size of the
+ * Boost.MPL Sequence, in which case this evaluates to void.
+ ******************************************************************************/
+
+template<
+ class Sequence, int Index,
+ int N = mpl::size< Sequence >::value
+>
+struct select
+ : mpl::at_c< Sequence, Index >
+{ };
+template< class Sequence, int N >
+struct select< Sequence, N, N >
+{ typedef void type; };
+
+/*******************************************************************************
+ * class deduce_common_type< T, U, NominalCandidates >
+ * struct nominal_candidates<T,U>
+ * struct common_type_dispatch_on_rvalueness<T,U>
+ * struct common_type_impl<T,U>
+ *
+ * These classes and structs implement the logic behind common_type, which goes
+ * roughly as follows. Let C be the type of the conditional expression
+ * declval< bool >() ? declval<T>() : declval<U>()
+ * if C is an rvalue, then:
+ * let T' and U' be T and U stripped of reference- and cv-qualifiers
+ * if T' and U' are pointer types, say, T' = V* and U' = W*, then:
+ * define the set of NominalCandidates to be
+ * { V*, W*, V'*, W'* }
+ * where V' is V with whatever cv-qualifiers are on W, and W' is W
+ * with whatever cv-qualifiers are on V
+ * else T' and U' are both "signable integral types" (integral and enum
+ * types excepting bool), then:
+ * define the set of NominalCandidates to be
+ * { unsigned(T'), unsigned(U'), signed(T'), signed(U') }
+ * where unsigned(X) is make_unsigned<X>::type and signed(X) is
+ * make_signed<X>::type
+ * else
+ * define the set of NominalCandidates to be
+ * { T', U' }
+ * else
+ * let V and W be T and U stripped of reference-qualifiers
+ * define the set of NominalCandidates to be
+ * { V&, W&, V'&, W'& }
+ * where V' is V with whatever cv-qualifiers are on W, and W' is W with
+ * whatever cv-qualifiers are on V
+ * define the set of Candidates to be equal to the set of NominalCandidates with
+ * duplicates removed, and use this set of Candidates to determine C using the
+ * conversion_test_overloads struct
+ ******************************************************************************/
+
+template< class T, class U, class NominalCandidates >
+class deduce_common_type
+{
+ typedef typename mpl::copy<
+ NominalCandidates,
+ mpl::inserter<
+ mpl::vector0<>,
+ mpl::if_<
+ mpl::contains< mpl::_1, mpl::_2 >,
+ mpl::_1,
+ mpl::push_back< mpl::_1, mpl::_2 >
+ >
+ >
+ >::type candidate_types;
+ static const int best_candidate_index =
+ sizeof( conversion_test_overloads< candidate_types >::apply(
+ declval< bool >() ? declval<T>() : declval<U>()
+ ) ) - 1;
+public:
+ typedef typename select< candidate_types, best_candidate_index >::type type;
+};
+
+template<
+ class T, class U,
+ class V = typename remove_cv< typename remove_reference<T>::type >::type,
+ class W = typename remove_cv< typename remove_reference<U>::type >::type,
+ bool = is_signable_integral<V>::value && is_signable_integral<W>::value
+>
+struct nominal_candidates;
+
+template< class T, class U, class V, class W >
+struct nominal_candidates< T, U, V, W, false >
+{ typedef mpl::vector2<V,W> type; };
+
+template< class T, class U, class V, class W >
+struct nominal_candidates< T, U, V, W, true >
+{
+ typedef mpl::vector4<
+ typename make_unsigned<V>::type,
+ typename make_unsigned<W>::type,
+ typename make_signed<V>::type,
+ typename make_signed<W>::type
+ > type;
+};
+
+template< class T, class U, class V, class W >
+struct nominal_candidates< T, U, V*, W*, false >
+{
+ typedef mpl::vector4<
+ V*, W*,
+ typename propagate_cv<W,V>::type *,
+ typename propagate_cv<V,W>::type *
+ > type;
+};
+
+template<
+ class T, class U,
+ bool = sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
+ declval< bool >() ? declval<T>() : declval<U>()
+ ) ) == sizeof( yes_type )
+>
+struct common_type_dispatch_on_rvalueness;
+
+template< class T, class U >
+struct common_type_dispatch_on_rvalueness< T, U, true >
+ : deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
+{ };
+
+template< class T, class U >
+struct common_type_dispatch_on_rvalueness< T, U, false >
+{
+private:
+ typedef typename remove_reference<T>::type unrefed_T_type;
+ typedef typename remove_reference<U>::type unrefed_U_type;
+public:
+ typedef typename deduce_common_type<
+ T, U,
+ mpl::vector4<
+ unrefed_T_type &,
+ unrefed_U_type &,
+ typename propagate_cv< unrefed_U_type, unrefed_T_type >::type &,
+ typename propagate_cv< unrefed_T_type, unrefed_U_type >::type &
+ >
+ >::type type;
+};
+
+template< class T, class U >
+struct common_type_impl
+ : common_type_dispatch_on_rvalueness<T,U>
+{ };
+
+template< class T > struct common_type_impl< T, void > { typedef void type; };
+template< class T > struct common_type_impl< void, T > { typedef void type; };
+template<> struct common_type_impl< void, void > { typedef void type; };
+template< > struct common_type_impl< char, short> { typedef int type; };
+template< > struct common_type_impl< short, char> { typedef int type; };
+template< > struct common_type_impl< unsigned char, short> { typedef int type; };
+template< > struct common_type_impl< short, unsigned char> { typedef int type; };
+template< > struct common_type_impl< unsigned char, unsigned short> { typedef int type; };
+template< > struct common_type_impl< unsigned short, unsigned char> { typedef int type; };
+template< > struct common_type_impl< char, unsigned short> { typedef int type; };
+template< > struct common_type_impl< unsigned short, char> { typedef int type; };
+
+} // namespace detail_type_traits_common_type
+
+
+} // namespace boost_ex
+
+#endif // BOOST_EX_TYPE_TRAITS_EXT_DETAIL_COMMON_TYPE_HPP