Subject: [Boost-commit] svn:boost r73711 - in sandbox/conversion/boost/conversion: . boost detail std type_traits type_traits/boost type_traits/boost/chrono type_traits/boost/fusion type_traits/boost/numeric type_traits/detail type_traits/std
From: vicente.botet_at_[hidden]
Date: 2011-08-13 05:31:19
Author: viboes
Date: 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
New Revision: 73711
URL: http://svn.boost.org/trac/boost/changeset/73711
Log:
conversion: a lot of changes going on for a concept based library allowing overloading of the provided functions.
Added:
sandbox/conversion/boost/conversion/detail/any.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/dummy_size.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_assignable_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_convertible_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_try_assignable_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_try_convertible_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/nat.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/yes_no_types.hpp (contents, props changed)
sandbox/conversion/boost/conversion/type_traits/detail/
sandbox/conversion/boost/conversion/type_traits/detail/any.hpp (contents, props changed)
sandbox/conversion/boost/conversion/type_traits/detail/dummy_size.hpp (contents, props changed)
sandbox/conversion/boost/conversion/type_traits/detail/nat.hpp (contents, props changed)
sandbox/conversion/boost/conversion/type_traits/detail/yes_no_types.hpp (contents, props changed)
Removed:
sandbox/conversion/boost/conversion/is_extrinsically_assignable_tagged.hpp
sandbox/conversion/boost/conversion/is_extrinsically_convertible_tagged.hpp
sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible2.hpp
sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible_tagged.hpp
Text files modified:
sandbox/conversion/boost/conversion/assign_to.hpp | 210 +++++++++++---------
sandbox/conversion/boost/conversion/assignable_to.hpp | 5
sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp | 31 --
sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp | 30 --
sandbox/conversion/boost/conversion/boost/interval.hpp | 4
sandbox/conversion/boost/conversion/boost/optional.hpp | 6
sandbox/conversion/boost/conversion/boost/rational.hpp | 4
sandbox/conversion/boost/conversion/boost/tuple.hpp | 4
sandbox/conversion/boost/conversion/config.hpp | 2
sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp | 76 ++++---
sandbox/conversion/boost/conversion/convertible_from.hpp | 24 +
sandbox/conversion/boost/conversion/explicit_convert_to.hpp | 79 ++++---
sandbox/conversion/boost/conversion/implicit_convert_to.hpp | 21 +
sandbox/conversion/boost/conversion/include.hpp | 2
sandbox/conversion/boost/conversion/is_extrinsically_assignable.hpp | 213 +++++++++++++++++++-
sandbox/conversion/boost/conversion/is_extrinsically_convertible.hpp | 205 +++++++++----------
sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible.hpp | 220 ++++++++++-----------
sandbox/conversion/boost/conversion/std/pair.hpp | 4
sandbox/conversion/boost/conversion/std/vector.hpp | 4
sandbox/conversion/boost/conversion/try_assign_to.hpp | 105 +++++++--
sandbox/conversion/boost/conversion/try_convert_to.hpp | 74 +++++--
sandbox/conversion/boost/conversion/type_traits/boost/array.hpp | 2
sandbox/conversion/boost/conversion/type_traits/boost/chrono/duration.hpp | 8
sandbox/conversion/boost/conversion/type_traits/boost/chrono/time_point.hpp | 8
sandbox/conversion/boost/conversion/type_traits/boost/fusion/tuple.hpp | 18
sandbox/conversion/boost/conversion/type_traits/boost/numeric/interval.hpp | 8
sandbox/conversion/boost/conversion/type_traits/boost/optional.hpp | 8
sandbox/conversion/boost/conversion/type_traits/boost/rational.hpp | 8
sandbox/conversion/boost/conversion/type_traits/is_assignable.hpp | 407 +++++++++++++++++++--------------------
sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp | 310 +++++++++++++++---------------
sandbox/conversion/boost/conversion/type_traits/is_convertible.hpp | 16
sandbox/conversion/boost/conversion/type_traits/is_copy_assignable.hpp | 2
sandbox/conversion/boost/conversion/type_traits/is_copy_constructible.hpp | 2
sandbox/conversion/boost/conversion/type_traits/is_default_constructible.hpp | 2
sandbox/conversion/boost/conversion/type_traits/is_destructible.hpp | 58 ++---
sandbox/conversion/boost/conversion/type_traits/is_explicitly_convertible.hpp | 67 ++---
sandbox/conversion/boost/conversion/type_traits/is_move_assignable.hpp | 5
sandbox/conversion/boost/conversion/type_traits/is_move_constructible.hpp | 5
sandbox/conversion/boost/conversion/type_traits/std/complex.hpp | 12
sandbox/conversion/boost/conversion/type_traits/std/utility.hpp | 14
sandbox/conversion/boost/conversion/type_traits/std/vector.hpp | 12
41 files changed, 1264 insertions(+), 1031 deletions(-)
Modified: sandbox/conversion/boost/conversion/assign_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/assign_to.hpp (original)
+++ sandbox/conversion/boost/conversion/assign_to.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -8,28 +8,19 @@
//
//////////////////////////////////////////////////////////////////////////////
-/*!
- @file
- @brief
- Defines the free function @c assign_to and its customization point @c assigner.
-
-The function @c assign_to assigns the @c from parameter to the @c to parameter.
-
+/**
+ * @file
+ * @brief
+ * Defines the free function @c assign_to and its customization point @c assigner.
+ *
+ * The function @c assign_to assigns the @c from parameter to the @c to parameter.
+ *
*/
+
#ifndef BOOST_CONVERSION_ASSIGN_TO_HPP
#define BOOST_CONVERSION_ASSIGN_TO_HPP
-/**
-A user adapting another type could need to specialize the @c assign_to free function if the default behavior is not satisfactory.
-The user can add the @c assign_to overloading on the namespace of the Source or Target classes.
-But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace,
-so we need a different technique. The technique consists in partially specialize on the function @c assign_to on
-the @c boost::conversion::overload_workaround namespace.
-
- */
#include <boost/conversion/config.hpp>
-
-
#include <cstddef> //for std::size_t
#include <boost/conversion/config.hpp>
#include <boost/conversion/convert_to.hpp>
@@ -38,37 +29,42 @@
#include <boost/conversion/type_traits/is_assignable.hpp>
#include <boost/conversion/is_extrinsically_convertible.hpp>
#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
+#include <boost/type_traits/add_reference.hpp>
namespace boost {
namespace conversion {
-
- //! Customization point for @c assign_to.
- //!
- //! @tparam Target target type of the conversion.
- //! @tparam Source source type of the conversion.
- //! @tparam Enable A dummy template parameter that can be used for SFINAE.
- //!
- //! This class must be specialized by the user when the default behavior of @c assigner is not satisfying.
- template < typename Target, typename Source, class Enable = void>
+ /** Customization point for @c assign_to.
+ *
+ * @tparam Target target type of the conversion.
+ * @tparam Source source type of the conversion.
+ * @tparam Enable A dummy template parameter that can be used for SFINAE.
+ *
+ * This class must be specialized by the user when the default behavior of
+ * @c assigner is not satisfying.
+ */
+ template < typename Target, typename Source, typename Enable = void>
struct assigner_cp : false_type {};
- //! Default customization point for @c assign_to.
- //!
- //! @tparam Target target type of the conversion.
- //! @tparam Source source type of the conversion.
- //! @tparam Enable A dummy template parameter that can be used for SFINAE.
- //!
- //! By default it delegates to the user @c assigner_cp.
- template < typename Target, typename Source, class Enable = void>
+ /** Default customization point for @c assign_to.
+ *
+ * @tparam Target target type of the conversion.
+ * @tparam Source source type of the conversion.
+ * @tparam Enable A dummy template parameter that can be used for SFINAE.
+ *
+ * By default it delegates to the user @c assigner_cp.
+ */
+ template < typename Target, typename Source, typename Enable = void>
struct assigner : assigner_cp<Target,Source,Enable> {};
/**
- * Specialization when @c Target is not assignable from @c Source, but @c Target is copy constructible and @c Source is extrinsic convertible to @c Target.
- //!
- //! @tparam Target target type of the conversion.
- //! @tparam Source source type of the conversion.
- //!
+ * Specialization when @c Target is not assignable from @c Source, but
+ * @c Target is copy constructible and @c Source is extrinsic convertible to
+ * @c Target.
+ *
+ * @tparam Target target type of the conversion.
+ * @tparam Source source type of the conversion.
+ *
* @Requires @c Target must be CopyAssinable and @c @c Source must be extrinsic convertible to @c Target.
*/
template < typename Target, typename Source>
@@ -88,14 +84,19 @@
#endif
> : true_type
{
- //! @Effects Converts the @c from parameter to the @c to parameter, using by default the assignment operator.
- //! @Throws Whatever the underlying assignment operator of the @c Target class throws.
+ /**
+ * @Effects Converts the @c from parameter to the @c to parameter, using
+ * by default the assignment operator.
+ * @Throws Whatever the underlying assignment operator of the @c Target
+ * class throws.
+ */
Target& operator()(Target& to, const Source& from)
{
to = ::boost::conversion::explicit_convert_to<Target>(from);
return to;
}
};
+
/**
* Specialization when @c Target is assignable from @c Source.
*
@@ -116,8 +117,11 @@
#endif
> : true_type
{
- //! @Effects Assigns the @c from parameter to the @c to parameter.
- //! @Throws Whatever the underlying assignment operator of the @c Target class throws.
+ /**
+ * @Effects Assigns the @c from parameter to the @c to parameter.
+ * @Throws Whatever the underlying assignment operator of the @c Target
+ * class throws.
+ */
Target& operator()(Target& to, const Source& from)
{
to = from;
@@ -146,9 +150,15 @@
#endif
> : true_type
{
- //! @Effects Converts the @c from parameter to the @c to parameter, using by default the assignment operator on each one of the array elements.
- //! @Throws Whatever the underlying assignment operator of the @c Target class throws.
- //! @Basic
+ /**
+ * @Effects Converts the @c from parameter to the @c to parameter,
+ * using by default the assignment operator on each one of the array
+ * elements.
+ * @Throws Whatever the underlying assignment operator of the @c Target
+ * class throws.
+ * @Basic
+ *
+ */
Target*& operator()(Target(&to)[N], const Source(& from)[N])
{
for (std::size_t i = 0; i < N; ++i)
@@ -166,44 +176,56 @@
* @tparam Source source type of the conversion.
* @tparam N the size of the c-arrays.
*
- * @Requires @c Target must be CopyAssinable and @c @c Source must be extrinsic convertible to @c Target.
+ * @Requires @c Target must be CopyAssinable and @c @c Source must be
+ * extrinsic convertible to @c Target.
*/
template < typename Target, typename Source, std::size_t N >
struct assigner<Target[N],Source[N]
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
- , requires(CopyAssignable<Target> && ExtrinsicallyConvertible<Source,Target>)
+ , requires(
+ CopyAssignable<Target>
+ && ExtrinsicallyConvertible<Source,Target>
+ )
#else
- , typename enable_if_c<
- is_copy_assignable<Target>::value
- && is_extrinsically_convertible<Source,Target>::value
- && ! is_assignable<Target,Source>::value
- >::type
+ , typename enable_if_c<
+ is_copy_assignable<Target>::value
+ && is_extrinsically_convertible<Source,Target>::value
+ && ! is_assignable<Target,Source>::value
+ >::type
#endif
> : true_type
{
- //! @Effects Converts the @c from parameter to the @c to parameter, using by default the assignment operator on each one of the array elements.
- //! @Throws Whatever the underlying assignment operator of the @c Target class throws.
- //! @Basic
+ /**
+ * @Effects Converts the @c from parameter to the @c to parameter, using
+ * by default the assignment operator on each one of the array elements.
+ * @Throws Whatever the underlying assignment operator of the @c Target
+ * class throws.
+ * @Basic
+ *
+ */
Target*& operator()(Target(&to)[N], const Source(& from)[N])
{
for (std::size_t i = 0; i < N; ++i)
{
- to[i] = ::boost::conversion::implicit_convert_to<Target>(from[i]);
+ to[i] = conversion::implicit_convert_to<Target>(from[i]);
}
return to;
}
};
-
}
#if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
namespace conversion_impl_2 {
- //! @brief Default @c assign_to overload, used when ADL fails.
- //!
- //! @Effects Converts the @c from parameter to the @c to parameter, using by default the assignment operator.
- //! @Throws Whatever the underlying the assignment operator of the @c Target class throws.
- //! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
+ /** @brief Default @c assign_to overload, used when ADL fails.
+ *
+ * @Effects Converts the @c from parameter to the @c to parameter, using
+ * by default the assignment operator.
+ * @Throws Whatever the underlying the assignment operator of the @c Target
+ * class throws.
+ * Forwards the call to the overload workaround, which can yet be
+ * specialized by the user for standard C++ types.
+ */
template < typename Target, typename Source >
typename enable_if_c<
conversion::assigner<Target,Source>::value
@@ -214,20 +236,19 @@
}
}
#endif
-
-
}
-#include <boost/conversion/is_extrinsically_assignable_tagged.hpp>
+#include <boost/conversion/detail/is_extrinsically_assignable_tagged.hpp>
namespace boost {
#if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
namespace conversion_impl {
template <typename Target, typename Source>
- Target&
- //typename enable_if_c<
- // is_extrinsically_assignable_tagged<Source,Target>::value
- //, Target&>::type
+ typename enable_if_c<
+ //true
+ conversion::is_extrinsically_assignable_tagged<Target,Source>::value
+ , Target&
+ >::type
assign_to_impl(Target& to, const Source& from)
{
using namespace boost::conversion_impl_2;
@@ -236,33 +257,36 @@
}
}
#endif
- namespace conversion {
- //! @brief Extrinsic assign function.
- //! Assigns the @c Source parameter to the @c Target one.
- //! This function can be seen as an emulation of free function overload of the assignment operator.
- //! @tparam Target target type of the conversion.
- //! @tparam Source source type of the conversion.
- //!
- //! @Params
- //! @Param{to,target of the conversion}
- //! @Param{from,source of the conversion}
-
- //! @Effects The ones of the assigner customization point.
- //! @Throws Whatever the assigner customization point throws.
- //! @Example
- //! @code
- //! Target t;
- //! Source s;
- //! boost::conversion::assign_to(t,s);
- //! @endcode
+ namespace conversion {
+ /** @brief Extrinsic assign function.
+ *
+ * Assigns the @c Source parameter to the @c Target one.
+ * This function can be seen as an emulation of free function overload of
+ * the assignment operator.
+ * @tparam Target target type of the conversion.
+ * @tparam Source source type of the conversion.
+ *
+ * @Params
+ * @Param{to,target of the conversion}
+ * @Param{from,source of the conversion}
+ *
+ * @Effects The ones of the assigner customization point.
+ * @Throws Whatever the assigner customization point throws.
+ * @Example
+ * @code
+ * Target t;
+ * Source s;
+ * boost::conversion::assign_to(t,s);
+ * @endcode
+ */
template <typename Target, typename Source>
- Target&
- //typename enable_if_c<
- // is_extrinsically_assignable_tagged<Source,Target>::value
- //, Target&>::type
+ typename enable_if_c<
+ is_extrinsically_assignable_tagged<Target,Source>::value
+ , Target&
+ >::type
assign_to(Target& to, const Source& from)
{
return boost::conversion_impl::assign_to_impl<Target, Source>(to, from);
Modified: sandbox/conversion/boost/conversion/assignable_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/assignable_to.hpp (original)
+++ sandbox/conversion/boost/conversion/assignable_to.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -11,8 +11,7 @@
/*!
@file
- @brief
- Defines the free function @c lvalue.
+ @brief Defines the free function @c assignable_to class and the factory @c lvalue.
*/
#ifndef BOOST_CONVERSION_ASSIGNABLE_TO_HPP
#define BOOST_CONVERSION_ASSIGNABLE_TO_HPP
@@ -90,7 +89,7 @@
};
//! makes an assignable to @c Target which accepts assignment from any type that is extrinsic assignable to @c Target.
- //! The result is able to transform conversion by convert_to calls and assignments by assign_to calls.
+ //! The result is able to transform assignments by assign_to calls.
//! @NoThrow.
template <typename Target>
assignable_to<Target> lvalue(Target& r)
Modified: sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -31,38 +31,11 @@
//! trick to generate the doc. Don't take care of it
struct trick_chrono_duration{};
#endif
-//#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
-// template <> struct is_constructible< posix_time::time_duration > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
-// template <> struct is_constructible< posix_time::time_duration, posix_time::time_duration const& > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
-// template <> struct is_assignable< posix_time::time_duration&, posix_time::time_duration const& > : true_type {};
-// template <> struct is_assignable< posix_time::time_duration, posix_time::time_duration > : true_type {};
-//#endif
-
-
-//#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
-// template < class Rep, class Period >
-// struct is_constructible< chrono::duration<Rep, Period> > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
-// template < class Rep, class Period >
-// struct is_constructible< chrono::duration<Rep, Period>, chrono::duration<Rep, Period> > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
-// template < class Rep, class Period >
-// struct is_assignable< chrono::duration<Rep, Period>&, chrono::duration<Rep, Period> const& > : true_type {};
-// template < class Rep, class Period >
-// struct is_assignable< chrono::duration<Rep, Period>, chrono::duration<Rep, Period> > : true_type {};
-//#endif
-
namespace conversion {
//! @brief @c implicit_converter specialization for conversions from @c boost::chrono::duration<> to @c boost::posix_time::time_duration.
//!
- template < class Rep, class Period>
+ template < typename Rep, typename Period>
struct implicit_converter_cp<posix_time::time_duration, chrono::duration<Rep, Period>
> : true_type
{
@@ -86,7 +59,7 @@
//! @brief @c implicit_converter specialization for conversions from @c boost::posix_time::time_duration to @c boost::chrono::duration<>.
//!
- template < class Rep, class Period>
+ template < typename Rep, typename Period>
struct implicit_converter_cp<chrono::duration<Rep, Period>, posix_time::time_duration
> : true_type
{
Modified: sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -32,36 +32,10 @@
//! trick to generate the doc. Don't take care of it
struct trick_chrono_time_point{};
#endif
-//#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
-// template <> struct is_constructible< boost::posix_time::ptime > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
-// template <> struct is_constructible< boost::posix_time::ptime, boost::posix_time::ptime const& > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
-// template <> struct is_assignable< boost::posix_time::ptime&, boost::posix_time::ptime const& > : true_type {};
-// template <> struct is_assignable< boost::posix_time::ptime, boost::posix_time::ptime > : true_type {};
-//#endif
-//
-//
-//#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
-// template < class Clock, class Duration>
-// struct is_constructible< chrono::time_point<Clock, Duration> > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
-// template < class Clock, class Duration>
-// struct is_constructible< chrono::time_point<Clock, Duration>, chrono::time_point<Clock, Duration> > : true_type {};
-//#endif
-//#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
-// template < class Clock, class Duration>
-// struct is_assignable< chrono::time_point<Clock, Duration>&, chrono::time_point<Clock, Duration> const& > : true_type {};
-// template < class Clock, class Duration>
-// struct is_assignable< chrono::time_point<Clock, Duration>, chrono::time_point<Clock, Duration> > : true_type {};
-//#endif
namespace conversion {
- template < class Clock, class Duration>
+ template < typename Clock, typename Duration>
struct implicit_converter_cp<posix_time::ptime, chrono::time_point<Clock, Duration>
> : true_type
{
@@ -83,7 +57,7 @@
}
};
- template < class Clock, class Duration>
+ template < typename Clock, typename Duration>
struct implicit_converter_cp<chrono::time_point<Clock, Duration>, posix_time::ptime
> : true_type
{
Modified: sandbox/conversion/boost/conversion/boost/interval.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/interval.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/interval.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -31,7 +31,7 @@
//! @brief @c implicit_converter specialization for source and target been @c boost::numeric::interval.
//!
- template < class Target, class PTarget, class Source, class PSource>
+ template < typename Target, typename PTarget, typename Source, typename PSource>
struct implicit_converter_cp< numeric::interval<Target,PTarget>, numeric::interval<Source,PSource>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
@@ -50,7 +50,7 @@
return numeric::interval<Target,PTarget>(boost::conversion::implicit_convert_to<Target>(from.lower()), boost::conversion::implicit_convert_to<Source>(from.upper()));
}
};
- template < class Target, class PTarget, class Source, class PSource>
+ template < typename Target, typename PTarget, typename Source, typename PSource>
struct assigner_cp< numeric::interval<Target,PTarget>, numeric::interval<Source,PSource>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
Modified: sandbox/conversion/boost/conversion/boost/optional.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/optional.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/optional.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -39,7 +39,7 @@
/**
* Partial specialization of @c implicit_converter for boost::optional
*/
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct implicit_converter_cp
< optional<Target>, optional<Source>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
@@ -65,7 +65,7 @@
//! @brief @c implicit_converter specialization to try to convert the source to @c Target::value_type when @c Target is optional.
//!
//! We can see this specialization as a try_convert_to function.
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct implicit_converter_cp< optional<Target>, Source
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
@@ -100,7 +100,7 @@
//! @brief @c explicit converter specialization to try to convert the source to @c Target::value_type when @c Target is optional.
//!
//! We can see this specialization as a try_convert_to function.
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct explicit_converter_cp< optional<Target>, Source
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
Modified: sandbox/conversion/boost/conversion/boost/rational.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/rational.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/rational.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -36,7 +36,7 @@
//! @brief @c implicit_converter specialization for source and target been @c boost::rational.
//!
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct implicit_converter_cp< rational<Target>, rational<Source>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
@@ -55,7 +55,7 @@
return rational<Target>(boost::conversion::convert_to<Target>(from.numerator()), boost::conversion::convert_to<Target>(from.denominator()));
}
};
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct assigner_cp< rational<Target>, rational<Source>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
Modified: sandbox/conversion/boost/conversion/boost/tuple.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/boost/tuple.hpp (original)
+++ sandbox/conversion/boost/conversion/boost/tuple.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -29,7 +29,7 @@
namespace conversion {
- template < class T1, class T2, class S1, class S2>
+ template < typename T1, typename T2, typename S1, typename S2>
struct explicit_converter_cp< fusion::tuple<T1,T2>, fusion::tuple<S1,S2>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
@@ -52,7 +52,7 @@
);
}
};
- template < class T1, class T2, class T3, class S1, class S2, class S3>
+ template < typename T1, typename T2, typename T3, typename S1, typename S2, typename S3>
struct explicit_converter_cp< fusion::tuple<T1,T2,T3>, fusion::tuple<S1,S2,S3>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
Modified: sandbox/conversion/boost/conversion/config.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/config.hpp (original)
+++ sandbox/conversion/boost/conversion/config.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -18,8 +18,6 @@
#include <boost/config.hpp>
#include <boost/utility/enable_if.hpp>
-//#define BOOST_CONVERSION_USES_SFINAE
-
#if !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
#if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
#else
Modified: sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp (original)
+++ sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -8,41 +8,35 @@
//
//////////////////////////////////////////////////////////////////////////////
-/*!
- @file
- @brief
- Defines the free function @c convert_to_or_fallback and its customization point @c converter_or_fallbacker_cp.
-
- The @c convert_to_or_fallback function converts the @c from parameter to a @c Target type. If the conversion fails the fallback value is used to construct a Target @c instance.
-
+/**
+ * @file
+ * @brief
+ * Defines the free function @c convert_to_or_fallback and its customization
+ * point @c converter_or_fallbacker_cp.
+ *
+ * The @c convert_to_or_fallback function converts the @c from parameter to a
+ * @c Target type. If the conversion fails the fallback value is used to
+ * construct a Target @c instance.
+ *
+ * The default implementation applies the conversion @c Target operator of the
+ * @c Source class or the copy constructor of the @c Target class.
+ * When an exception is thrown the fallback is returned.
+ * Of course if both exist the conversion is ambiguous.
*/
#ifndef BOOST_CONVERSION_CONVERT_TO_OR_FALLBACK_HPP
#define BOOST_CONVERSION_CONVERT_TO_OR_FALLBACK_HPP
-/**
- The default implementation applies the conversion @c Target operator of the @c Source class or
- the copy constructor of the @c Target class. When an exception is thrown the fallback is returned.
- Of course if both exist the conversion is ambiguous.
- A user adapting another type could need to specialize the @c convert_to_or_fallback free function if the default behavior is not satisfactory.
- * A user adapting another type could need to overload the @c convert_to_or_fallback free function
- * if the default behavior is not satisfactory.
- * The user can add the @c convert_to_or_fallback overloading on any namespace found by ADL from the @c Source or the @c Target.
- * A trick is used to overload on the return type by adding a dummy parameter having the Target.
- *
- * But sometimes, as it is the case for the standard classes,
- * we can not add new functions on the @c std namespace, so we need a different technique.
- * In this case the user can partially specialize the @c boost::conversion::overload_workaround::convert_to_or_fallback struct.
- */
-
#include <boost/conversion/config.hpp>
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/integral_constant.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost {
namespace conversion {
+
//! Customization point for @c convert_to_or_fallback.
//!
//! @tparam Target target type of the conversion.
@@ -51,8 +45,8 @@
//! @tparam Enable A dummy template parameter that can be used for SFINAE.
//!
//! This class must be specialized by the user.
- template < typename Target, typename Source, typename Fallback=Target, class Enable = void>
- struct converter_or_fallbacker_cp {};
+ template < typename Target, typename Source, typename Fallback=Target, typename Enable = void>
+ struct converter_or_fallbacker_cp : false_type {};
//! Default @c converter_or_fallbacker.
//!
@@ -62,7 +56,7 @@
//! @tparam Enable A dummy template parameter that can be used for SFINAE.
//!
//! The default implementation relies on the @c converter_or_fallbacker_cp customization point which must be specialized by the user.
- template < typename Target, typename Source, typename Fallback=Target, class Enable = void>
+ template < typename Target, typename Source, typename Fallback=Target, typename Enable = void>
struct converter_or_fallbacker : converter_or_fallbacker_cp<Target,Source,Fallback,Enable> {};
//! Specialization for @c converter_or_fallbacker when
@@ -77,15 +71,16 @@
template < typename Target, typename Source, typename Fallback>
struct converter_or_fallbacker<Target, Source, Fallback,
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
- requires(ExtrinsicallyExplicitConvertible<Source,Target> && ExtrinsicallyExplicitConvertible<Fallback,Target>)
+ requires(ExtrinsicallyExplicitConvertible<Source,Target>
+ && ExtrinsicallyExplicitConvertible<Fallback,Target>)
#else
typename enable_if_c<
is_extrinsically_explicit_convertible<Source,Target>::value
&& is_extrinsically_explicit_convertible<Fallback,Target>::value
>::type
#endif
- > {
- //!
+ > : true_type
+ {
//! @Returns The converted value if the conversion succeeds or the conversion of the fallback.
//! @Throws Whatever the conversion from @c Fallback to @c Target can throws when the conversion fails.
Target operator()(const Source& val, Fallback const& fallback)
@@ -112,20 +107,33 @@
//! @NoThrow
//! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
template < typename Target, typename Source, typename Fallback >
- Target convert_to_or_fallback(const Source& from, Fallback const& fallback, dummy::type_tag<Target> const&) {
- return conversion::converter_or_fallbacker<Target,Source,Fallback>()(from, fallback);
+ typename enable_if_c<
+ converter_or_fallbacker<Target,Source,Fallback>::value
+ ,
+ Target
+ >::type
+ convert_to_or_fallback(const Source& from, Fallback const& fallback, dummy::type_tag<Target> const&) {
+ return converter_or_fallbacker<Target,Source,Fallback>()(from, fallback);
}
}
namespace impl {
template <typename Target, typename Source, typename Fallback>
- Target convert_to_or_fallback_impl(Source const& from, Fallback const& fallback) {
+ Target
+ convert_to_or_fallback_impl(Source const& from, Fallback const& fallback) {
using namespace boost::conversion::impl_2;
//use boost::conversion::impl_2::convert_to_or_fallback if ADL fails
return convert_to_or_fallback(from, fallback, dummy::type_tag<Target>());
}
}
#endif
+ }
+}
+
+#include <boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp>
+
+namespace boost {
+ namespace conversion {
//! @brief Extrinsic conversion function with fallback.
//! Converts the @c from parameter to a @c Target type. If the conversion fails the fallback value is used to construct a Target @c instance.
@@ -144,6 +152,7 @@
template <typename Target, typename Source, typename Fallback>
typename enable_if_c<
! is_same<Target,Fallback>::value
+ && is_extrinsically_explicit_convertible_or_fallback_tagged<Source,Target,Fallback>::value
, Target>::type
convert_to_or_fallback(Source const& from, Fallback const& fallback) {
return conversion::impl::convert_to_or_fallback_impl<Target>(from, fallback);
@@ -161,7 +170,10 @@
//! int t=boost::conversion::convert_to_or_fallback(s,-1);
//! @endcode
template <typename Target, typename Source>
- Target convert_to_or_fallback(Source const& from, Target const& fallback) {
+ typename enable_if_c<
+ is_extrinsically_explicit_convertible_or_fallback_tagged<Source,Target,Target>::value
+ , Target>::type
+ convert_to_or_fallback(Source const& from, Target const& fallback) {
return conversion::impl::convert_to_or_fallback_impl<Target>(from, fallback);
}
}
Modified: sandbox/conversion/boost/conversion/convertible_from.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convertible_from.hpp (original)
+++ sandbox/conversion/boost/conversion/convertible_from.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -24,6 +24,7 @@
#include <boost/conversion/assign_to.hpp>
#include <boost/conversion/is_extrinsically_convertible.hpp>
#include <boost/utility/enable_if.hpp>
+#include <boost/conversion/type_traits/is_copy_constructible.hpp>
namespace boost {
namespace conversion {
@@ -35,7 +36,17 @@
//!
//! Requires @c Source must be CopyConstructible
- template <typename Source>
+ template <typename Source, typename Enable =
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ requires(
+ CopyConstructible<Source>
+ )
+#else
+ typename enable_if_c<
+ is_copy_constructible<Source>::value
+ >::type
+#endif
+ >
class convertible_from {
Source val_;
public:
@@ -59,9 +70,10 @@
}
};
- //! @brief makes a wrapper implicitly convertible to types extrinsicly implicit convertibles from @c Source.
- //! The result provides implicitly conversion to any type which is extrinsic implicit convertible from @c Source.
+ //! @brief makes a wrapper implicitly convertible to types extrinsicly implicit convertibles from @c Source.
+ //!
+ //! The result provides implicitly conversion to any type which is extrinsically implicit convertible from @c Source.
//! @Returns convertible_from<Source>(s).
//! @NoThrow.
//! @Example
@@ -77,7 +89,11 @@
//! @endcode
template <typename Source>
- convertible_from<Source> implicitly(Source s)
+ typename enable_if_c<
+ is_copy_constructible<Source>::value
+ , convertible_from<Source>
+ >::type
+ implicitly(Source s)
{
return convertible_from<Source>(s);
}
Added: sandbox/conversion/boost/conversion/detail/any.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/any.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the any type useful to catch any type on overloadin resolution.
+ */
+
+#ifndef BOOST_CONVERSION_DETAIL_ANY_HPP
+#define BOOST_CONVERSION_DETAIL_ANY_HPP
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ struct any {
+ template <typename T>
+ any(T);
+ };
+ } // detail
+} // conversion
+} // boost
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/dummy_size.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/dummy_size.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,31 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the dummy_size useful to to accept a sizeof as parameter.
+ */
+
+#ifndef BOOST_CONVERSION_DETAIL_DUMMY_SIZE_HPP
+#define BOOST_CONVERSION_DETAIL_DUMMY_SIZE_HPP
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+
+ //! type useful to accept a sizeof as parameter
+ template <std::size_t N>
+ struct dummy_size;
+
+ } // detail
+ } // conversion
+} // boost
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_assignable_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_assignable_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,209 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the type trait @c is_extrinsically_assignable_tagged.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_HPP
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+namespace boost {
+ namespace conversion {
+ /**
+ * States if @c Source is extrinsically assignable to @c Target.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * Target test() { return implicit_convert_to<Target>(declval<Source>()); }
+ * @endcode
+ *
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Target, typename Source>
+ struct is_extrinsically_assignable_tagged {};
+
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_assignable type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+
+ }
+}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/conversion/detail/any.hpp>
+#include <boost/conversion/detail/yes_no_types.hpp>
+#include <boost/conversion/detail/dummy_size.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+ #endif
+ #else
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+ #endif
+ #else
+#error
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined _MSC_VER
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+#elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ namespace is_extrinsically_assignable_tagged {
+ using namespace boost::conversion_impl_2;
+
+ template <typename T, typename S,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_assignable<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template <typename T1, typename S1>
+ static decltype((
+ assign_to(declval<T1>(), declval<S1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
+ selector(T1&&, S1&&);
+ #else
+ selector(T1&, S1&);
+ #endif
+
+ template <typename T1, typename S1>
+ static false_type
+ selector(any,any);
+
+ typedef typename common_type<decltype(selector(declval<T>(), declval<S>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
+
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template<typename T1, typename S1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ assign_to(declval<T1>(), declval<S1>()) // EXPR
+ )
+ >*);
+
+ template<typename T1, typename S1>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename T,typename S>
+ struct imp<T,S,false,false>
+ : public conversion::assigner<T,S> {};
+#endif
+
+ template <typename T,typename S,bool B>
+ struct imp<T, S, true, B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<T, S, B, true>
+ : public false_type {};
+
+ } // is_extrinsically_assignable_tagged
+ } // detail
+
+
+ template <typename Target, typename Source>
+ struct is_extrinsically_assignable_tagged
+ : public detail::is_extrinsically_assignable_tagged::imp<Target, Source> {};
+
+ } // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_convertible_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_convertible_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,225 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the type trait @c is_extrinsically_convertible_tagged.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_HPP
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+namespace boost {
+ namespace conversion {
+ /**
+ * States if @c Source is extrinsically explicit convertible to @c Target.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * Target test() { return implicit_convert_to<Target>(declval<Source>()); }
+ * @endcode
+ *
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Source, typename Target>
+ struct is_extrinsically_convertible_tagged {};
+
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_convertible type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
+
+ }
+}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/conversion/detail/any.hpp>
+#include <boost/conversion/detail/yes_no_types.hpp>
+#include <boost/conversion/detail/dummy_size.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/implicit_convert_to.hpp>
+
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
+ #endif
+ #else
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
+ #endif
+ #else
+#error
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined _MSC_VER
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+#elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ namespace is_extrinsically_convertible_tagged {
+ using namespace boost::conversion::impl_2;
+
+ template <typename S, typename T,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template <typename S1, typename T1>
+ static decltype((
+ implicit_convert_to(declval<S1>(), conversion::dummy::type_tag<T1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
+ selector(S1&&, T1&&);
+ #else
+ selector(S1&, T1&);
+ #endif
+
+ template <typename S1, typename T1>
+ static false_type
+ selector(any,any);
+
+ typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
+
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template<typename X, typename Y>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ implicit_convert_to(declval<X>(), conversion::dummy::type_tag<Y>()) // EXPR
+ )
+ >*);
+
+ template<typename X, typename Y>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename S,typename T>
+ struct imp<S,T,false,false>
+ : public conversion::implicit_converter<T,S> {};
+#endif
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T,false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S,T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T[],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T,false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S,T[],false,false>
+ : public false_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, true,B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, B,true>
+ : public false_type {};
+
+ } // is_extrinsically_convertible_tagged
+ } // detail
+
+
+ template <typename Source, typename Target>
+ struct is_extrinsically_convertible_tagged
+ : public detail::is_extrinsically_convertible_tagged::imp<Source, Target> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,222 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the type trait @c is_extrinsically_explicit_convertible_or_fallback.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_HPP
+
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+namespace boost {
+ namespace conversion {
+ /**
+ * States if @c Source is extrinsically explicit convertible to @c Target.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * Target test() { return explicit_convert_to<Target>(declval<Source>()); }
+ * @endcode
+ *
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Source, typename Target>
+ struct is_extrinsically_explicit_convertible_or_fallback_tagged {};
+
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible_or_fallback type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED
+
+ }
+}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/conversion/detail/any.hpp>
+#include <boost/conversion/detail/yes_no_types.hpp>
+#include <boost/conversion/detail/dummy_size.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/type_traits/is_convertible.hpp>
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED
+ #endif
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_DECLTYPE
+ #endif
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_DECLTYPE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined __clang__
+#error
+#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #else
+ #error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace impl_2 {}
+ namespace detail {
+ namespace is_extrinsically_explicit_convertible_or_fallback_tagged {
+ using namespace boost::conversion::impl_2;
+
+ template <typename S, typename T, typename F,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value
+ >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_DECLTYPE
+ template <typename S, typename T, typename F>
+ struct imp<S,T,F,false,false>
+ {
+ template<typename S1, typename T1, typename F1>
+ static decltype((
+ convert_to_or_fallback(declval<S1>(),declval<F1>(), conversion::dummy::type_tag<T1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ selector(S1&&, T1&&, F1&&);
+ #else
+ selector(S1&, T1&, F1&);
+ #endif
+
+ template<typename S1, typename T1, typename F1>
+ static false_type
+ selector(any,any,any);
+
+ typedef typename common_type<decltype(selector(declval<S>(), declval<T>(), declval<F>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+
+ template <typename S, typename T, typename F>
+ struct imp<S,T,F,false,false>
+ {
+ template<typename S1, typename T1, typename F1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ convert_to_or_fallback(declval<S1>(),declval<F1>(), conversion::dummy::type_tag<T1>()) // EXPR
+ )
+ >*);
+
+ template<typename S1, typename T1, typename F1>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T,F>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename S, typename T, typename F>
+ struct imp<S,T,F,false,false>
+ : public conversion::converter_or_fallbacker<T,S,F> {};
+#endif
+ template <typename S, typename T, typename F, std::size_t N>
+ struct imp<S[N],T[N],F,false,false>
+ : public false_type {};
+ template <typename S, typename T, typename F, std::size_t N>
+ struct imp<S[N],T,F,false,false>
+ : public false_type {};
+ template <typename S, typename T, typename F, std::size_t N>
+ struct imp<S,T[N],F,false,false>
+ : public false_type {};
+ template <typename S, typename T, typename F>
+ struct imp<S[],T[],F,false,false>
+ : public false_type {};
+ template <typename S, typename T, typename F>
+ struct imp<S[],T,F,false,false>
+ : public false_type {};
+ template <typename S, typename T, typename F>
+ struct imp<S,T[],F,false,false>
+ : public false_type {};
+
+ template <typename S,typename T, typename F,bool B>
+ struct imp<S, T, F, true, B>
+ : public true_type {};
+
+ template <typename S,typename T, typename F,bool B>
+ struct imp<S, T, F, B, true>
+ : public false_type {};
+
+ } // is_extrinsically_explicit_convertible_or_fallback_tagged
+ } // detail
+
+
+ template <typename Source, typename Target, typename Fallback>
+ struct is_extrinsically_explicit_convertible_or_fallback_tagged
+ : public detail::is_extrinsically_explicit_convertible_or_fallback_tagged::imp<Source, Target, Fallback> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,224 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the type trait @c is_extrinsically_explicit_convertible.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_HPP
+
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+namespace boost {
+ namespace conversion {
+ /**
+ * States if @c Source is extrinsically explicit convertible to @c Target.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * Target test() { return explicit_convert_to<Target>(declval<Source>()); }
+ * @endcode
+ *
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Source, typename Target>
+ struct is_extrinsically_explicit_convertible_tagged {};
+
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
+
+ }
+}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/conversion/detail/any.hpp>
+#include <boost/conversion/detail/yes_no_types.hpp>
+#include <boost/conversion/detail/dummy_size.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/type_traits/is_convertible.hpp>
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
+ #endif
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #endif
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined __clang__
+ #error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace impl_2 {}
+ namespace detail {
+ namespace is_extrinsically_explicit_convertible_tagged {
+ using namespace boost::conversion::impl_2;
+
+ template <typename S, typename T,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value
+ >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template <typename S1, typename T1>
+ static decltype((
+ explicit_convert_to(declval<S1>(), conversion::dummy::type_tag<T1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
+ selector(S1&&, T1&&);
+ #else
+ selector(S1&, T1&);
+ #endif
+
+ template <typename S1, typename T1>
+ static false_type
+ selector(any,any);
+
+ typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
+
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template<typename S1, typename T1>
+ static yes_type
+ selector(
+ dummy_size<
+ sizeof(
+ explicit_convert_to(declval<S1>(), conversion::dummy::type_tag<T1>()) // EXPR
+ )
+ >*
+ );
+
+ template<typename S1, typename T1>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ : public conversion::explicit_converter<T,S> {};
+#endif
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T,false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S,T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T[],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T,false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S,T[],false,false>
+ : public false_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, true,B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, B,true>
+ : public false_type {};
+
+ } // is_extrinsically_explicit_convertible_tagged
+ } // detail
+
+
+ template <typename Source, typename Target>
+ struct is_extrinsically_explicit_convertible_tagged
+ : public detail::is_extrinsically_explicit_convertible_tagged::imp<Source, Target> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_try_assignable_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_try_assignable_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,211 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the type trait @c is_extrinsically_try_assignable_tagged.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_HPP
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+namespace boost {
+ namespace conversion {
+ /**
+ * States if @c Source is extrinsically assignable to @c Target.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * Target test() { return implicit_convert_to<Target>(declval<Source>()); }
+ * @endcode
+ *
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Source, typename Target>
+ struct is_extrinsically_try_assignable_tagged {};
+
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_try_assignable type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+
+ }
+}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/conversion/detail/any.hpp>
+#include <boost/conversion/detail/yes_no_types.hpp>
+#include <boost/conversion/detail/dummy_size.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/type_traits/is_assignable.hpp>
+#include <boost/conversion/try_assign_to.hpp>
+
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+ #endif
+ #else
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+ #endif
+ #else
+#error
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined _MSC_VER
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+#elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ namespace is_extrinsically_try_assignable_tagged {
+ using namespace boost::conversion_impl_2;
+
+
+ template <typename T, typename S,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_assignable<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_DECLTYPE
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template <typename T1, typename S1>
+ static decltype((
+ try_assign_to(declval<T1>(), declval<S1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_RVALUE
+ selector(T1&&, S1&&);
+ #else
+ selector(T1&, S1&);
+ #endif
+
+ template <typename S1, typename T1>
+ static false_type
+ selector(any,any);
+
+ typedef typename common_type<decltype(selector(declval<T>(), declval<S>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_TRY_ASSIGNABLE_TAGGED_USES_SIZEOF
+
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template<typename T1, typename S1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ try_assign_to(declval<T1>(), declval<S1>()) // EXPR
+ )
+ >*);
+
+ template<typename T1, typename S1>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename T,typename S>
+ struct imp<T,S,false,false>
+ : public conversion::try_assigner<T,S> {};
+#endif
+
+ template <typename T,typename S,bool B>
+ struct imp<T, S, true, B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<T, S, B, true>
+ : public false_type {};
+
+ } // is_extrinsically_try_assignable_tagged
+ } // detail
+
+
+ template <typename Target, typename Source>
+ struct is_extrinsically_try_assignable_tagged
+ : public detail::is_extrinsically_try_assignable_tagged::imp<Target, Source> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_try_convertible_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_try_convertible_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,225 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the type trait @c is_extrinsically_try_convertible.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_HPP
+
+
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+namespace boost {
+ namespace conversion {
+ /**
+ * States if @c Source is extrinsically try convertible to @c Target.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * Target test() { return try_convert_to<Target>(declval<Source>()); }
+ * @endcode
+ *
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Source, typename Target>
+ struct is_extrinsically_try_convertible_tagged {};
+
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_try_convertible type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED
+
+ }
+}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/conversion/detail/any.hpp>
+#include <boost/conversion/detail/yes_no_types.hpp>
+#include <boost/conversion/detail/dummy_size.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/try_convert_to.hpp>
+#include <boost/conversion/type_traits/is_convertible.hpp>
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+//#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED
+ #endif
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #endif
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined __clang__
+#error
+#define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED
+ #else
+ #error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace impl_2 {}
+ namespace detail {
+ namespace is_extrinsically_try_convertible_tagged {
+ using namespace boost::conversion::impl_2;
+
+ template <typename S, typename T,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value
+ >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template <typename S1, typename T1>
+ static decltype((
+ try_convert_to(declval<S1>(), conversion::dummy::type_tag<T1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_RVALUE
+ selector(S1&&, T1&&);
+ #else
+ selector(S1&, T1&);
+ #endif
+
+ template <typename S1, typename T1>
+ static false_type
+ selector(any,any);
+
+ typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_TRY_CONVERTIBLE_TAGGED_USES_SIZEOF
+
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template<typename X, typename Y>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ try_convert_to(declval<X>(), conversion::dummy::type_tag<Y>()) // EXPR
+ )
+ >*);
+
+ template<typename X, typename Y>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ : public conversion::try_converter<T,S> {};
+#endif
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T,false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S,T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T[],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T,false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S,T[],false,false>
+ : public false_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, true,B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, B,true>
+ : public false_type {};
+
+ } // is_extrinsically_try_convertible_tagged
+ } // detail
+
+
+ template <typename Source, typename Target>
+ struct is_extrinsically_try_convertible_tagged
+ : public detail::is_extrinsically_try_convertible_tagged::imp<Source, Target> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/nat.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/nat.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,29 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the nat type used as default of variadic templates to mean not a type.
+ */
+
+#ifndef BOOST_CONVERSION_DETAIL_NAT_HPP
+#define BOOST_CONVERSION_DETAIL_NAT_HPP
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ //! not a type. used as default of variadic templates
+ struct nat {};
+
+ } // detail
+} // conversion
+} // boost
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/yes_no_types.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/yes_no_types.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the any type useful to catch any type on overload resolution.
+ */
+
+#ifndef BOOST_CONVERSION_DETAIL_YES_NO_TYPES_HPP
+#define BOOST_CONVERSION_DETAIL_YES_NO_TYPES_HPP
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+
+ //! type useful to compare with the sizeof
+ typedef char yes_type;
+ //! type useful to compare with the sizeof
+ struct no_type { char a[2]; };
+
+ } // detail
+ } // conversion
+} // boost
+
+#endif // header
+
Modified: sandbox/conversion/boost/conversion/explicit_convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/explicit_convert_to.hpp (original)
+++ sandbox/conversion/boost/conversion/explicit_convert_to.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -9,25 +9,31 @@
//////////////////////////////////////////////////////////////////////////////
/**
* @file
- * @brief Defines the free function @c explicit_convert_to and its customization point @c explicit_converter.
+ * @brief Defines the free function @c explicit_convert_to and its customization
+ * point @c explicit_converter.
*
- * The @c explicit_convert_to function explicit converts the @c from parameter to a @c Target type.
+ * The @c explicit_convert_to function explicit converts the @c from parameter
+ * to a @c Target type.
*
- */
-#ifndef BOOST_CONVERSION_EXPLICIT_CONVERT_TO_HPP
-#define BOOST_CONVERSION_EXPLICIT_CONVERT_TO_HPP
-/**
- * A user adapting another type could need to overload the @c explicit_convert_to free function
- * if the default behavior is not satisfactory.
- * The user can add the @c explicit_convert_to overloading on any namespace found by ADL from the @c Source or the @c Target.
- * A trick is used to overload on the return type by adding a dummy parameter having the Target.
+ * The default behavior returns the explicit conversion operator when @c Source is
+ * implicitly convertible to @c Target and the extrinsic implicit conversion when
+ * @c Source is extrinsically implicitly convertible to @c Target.
+ *
+ * When the default behavior is not satisfactory or it doesn't takes care of
+ * specific types, the user could customize the behavior of
+ * @c explicit_convert_to in two ways:
*
- * But sometimes, as it is the case for the standard classes,
- * we can not add new functions on the @c std namespace, so we need a different technique.
- * In this case the user can partially specialize the @c boost::conversion::overload_workaround::explicit_convert_to struct.
+ * * overload the @c explicit_convert_to on any namespace found by ADL from the
+ * @c Source or the @c Target. A trick is used to overload on the return type
+ * by adding a dummy parameter depending on the @c Target.
+ * * partially specialize the @c boost::conversion::explicit_converter_cp struct.
*
+ * @note As we can not add new functions on the @c std namespace, partial
+ * specialization is the only option.
*/
+#ifndef BOOST_CONVERSION_EXPLICIT_CONVERT_TO_HPP
+#define BOOST_CONVERSION_EXPLICIT_CONVERT_TO_HPP
#include <boost/conversion/implicit_convert_to.hpp>
#include <boost/utility/enable_if.hpp>
@@ -37,6 +43,7 @@
#include <boost/conversion/is_extrinsically_convertible.hpp>
#include <boost/conversion/detail/is_optional.hpp>
#include <boost/optional.hpp>
+#include <boost/type_traits/add_reference.hpp>
namespace boost {
namespace conversion {
@@ -48,7 +55,7 @@
//! @tparam Enable A dummy template parameter that can be used for SFINAE.
//!
//! This class must be specialized by the user when the default behavior of @c explicit_converter is not satisfying.
- template < typename Target, typename Source, class Enable = void >
+ template < typename Target, typename Source, typename Enable = void >
struct explicit_converter_cp : false_type {};
//! Default @c explicit_converter.
@@ -58,7 +65,7 @@
//! @tparam Enable A dummy template parameter that can be used for SFINAE.
//!
//! The default implementation relies on the @c explicit_converter_cp which must be specialized by the user.
- template < typename Target, typename Source, class Enable = void >
+ template < typename Target, typename Source, typename Enable = void >
struct explicit_converter : explicit_converter_cp<Target,Source,Enable> {};
//! Specialization for @c explicit_converter when @c is_explicitly_convertible<Source,Target>.
@@ -74,20 +81,21 @@
#else
typename enable_if_c<
is_explicitly_convertible<Source,Target>::value
- && !(detail::is_optional<Target>::value && !detail::is_optional<Source>::value)
+ && !( detail::is_optional<Target>::value &&
+ ! detail::is_optional<Source>::value)
>::type
#endif
> : true_type
{
//! @Effects Converts the @c from parameter to an instance of the @c Target type, using the conversion operator or copy constructor.
//! @Throws Whatever the underlying conversion @c Target operator of the @c Source class throws.
- //Target operator()(const typename add_reference<Source>::type val)
Target operator()(const Source& val)
+ //Target operator()(const Source& val)
{
return Target((val));
}
};
- //! Specialization for @c explicit_converter when @c is_explicitly_convertible<Source,Target>.
+ //! Specialization for @c explicit_converter when @c is_extrinsically_convertible<Source,Target>.
//!
//! @tparam Target target type of the conversion.
//! @tparam Source source type of the conversion.
@@ -101,13 +109,14 @@
typename enable_if_c<
is_extrinsically_convertible<Source,Target>::value
&& !is_explicitly_convertible<Source,Target>::value
- && !(detail::is_optional<Target>::value && !detail::is_optional<Source>::value)
+ && !( detail::is_optional<Target>::value &&
+ ! detail::is_optional<Source>::value)
>::type
#endif
> : true_type
{
//! @Effects Converts the @c from parameter to an instance of the @c Target type, using the conversion operator or copy constructor.
- //! @Throws Whatever the underlying conversion @c Target operator of the @c Source class throws.
+ //! @Throws Whatever the expression @c implicit_convert_to<Target>(val) throws.
Target operator()(const Source& val)
{
return implicit_convert_to<Target>(val);
@@ -120,14 +129,16 @@
//! @brief Default @c explicit_convert_to overload, used when ADL fails.
//!
- //! @Effects Converts the @c from parameter to an instance of the @c Target type, using by default the conversion operator or copy constructor.
- //! @Throws Whatever the underlying conversion @c Target operator of the @c Source class or the copy constructor of the @c Target class throws.
- //! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
+ //! @Effects Converts the @c from parameter to an instance of the @c Target type,
+ //! using by explicit_converter customization point.
+ //! @Throws Whatever the expression @c conversion::explicit_converter<Target,Source>()(from) throws.
+
template < typename Target, typename Source >
typename enable_if_c<
conversion::explicit_converter<Target,Source>::value
, Target>::type
- explicit_convert_to(const Source& from, dummy::type_tag<Target> const&)
+ explicit_convert_to(const Source& from,
+ dummy::type_tag<Target> const&)
{
return conversion::explicit_converter<Target,Source>()(from);
}
@@ -138,22 +149,23 @@
}
}
-#include <boost/conversion/is_extrinsically_explicit_convertible_tagged.hpp>
+#include <boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp>
namespace boost {
namespace conversion {
//! @brief Extrinsic conversion function.
//! Converts the @c from parameter to an instance of the @c Target type.
- //! This function can be seen as an emulation of free function overload of the conversion operator.
+ //! This function can be seen as an emulation of free function overload of
+ //! the conversion operator.
//! @tparam Target target type of the conversion.
//! @tparam Source source type of the conversion.
//!
//! @Params
//! @Param{source,source of the conversion}
//!
- //! @Returns The result of @c explicit_converter customization point.
- //! @Throws Whatever the @c explicit_converter call operator throws.
+ //! @Returns @c explicit_convert_to(from, dummy::type_tag<Target>()).
+ //! @Throws Whatever the @c explicit_convert_to(from, dummy::type_tag<Target>()) throws.
//!
//! @Example
//! @code
@@ -172,14 +184,15 @@
return explicit_convert_to(from, dummy::type_tag<Target>());
}
- //! @brief @c explicit converter specialization to try to convert the source to @c Target::value_type when @c Target is optional.
+ //! @brief @c explicit converter specialization to try to convert the source
+ //! to @c Target when the target type is @c optional<Target>.
//!
//! @tparam Target target type of the conversion.
//! @tparam Source source type of the conversion.
//!
//! @Requires @c is_extrinsically_explicit_convertible<Source,Target>
- //! We can see this specialization as a try_convert_to function.
- template < class Target, class Source>
+ //! @Remarks We can see this specialization as a try_convert_to function.
+ template < typename Target, typename Source>
struct explicit_converter< optional<Target>, Source,
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
requires(ExtrinsicallyExplicitConvertible<Source,Target>)
@@ -193,8 +206,8 @@
{
//! @Returns If the source is convertible to the target @c value_type
- //! @c Target initialized to the result of the conversion.
- //! Uninitialized @c Target otherwise.
+ //! @c optional<Target> is initialized to the result of the conversion.
+ //! Uninitialized @c optional<Target> otherwise.
optional<Target> operator()(Source const & from)
{
try
Modified: sandbox/conversion/boost/conversion/implicit_convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/implicit_convert_to.hpp (original)
+++ sandbox/conversion/boost/conversion/implicit_convert_to.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -16,7 +16,7 @@
* The @c implicit_convert_to function converts the @c from parameter to a
* @c Target type and is intended to be used in a implicit context.
*
- * The default behavior call the implicit conversion when @c Source is
+ * The default behavior returns the implicit conversion when @c Source is
* implicitly convertible to @c Target
*
* When the default behavior is not satisfactory or it doesn't takes care of
@@ -64,7 +64,7 @@
//!
//! This class can be specialized by the user when the default behavior of
//! @c implicit_converter doesn't takes care of he specific types.
- template < typename Target, typename Source, class Enable = void >
+ template < typename Target, typename Source, typename Enable = void >
struct implicit_converter_cp : false_type {};
//! Default customization point for @c implicit_convert_to.
@@ -75,7 +75,7 @@
//!
//! The default implementation relies on the @c implicit_converter_cp which
//! must be specialized by the user.
- template < typename Target, typename Source, class Enable = void >
+ template < typename Target, typename Source, typename Enable = void >
struct implicit_converter : implicit_converter_cp<Target,Source,Enable> {};
@@ -100,7 +100,7 @@
* @c Target type, using the conversion operator or copy constructor.
* @Throws Whatever the underlying conversion @c Target operator of the @c Source class throws.
*/
- Target operator()(typename add_reference<const Source>::type val)
+ Target operator()(const Source& val)
{
return val;
}
@@ -118,7 +118,8 @@
typename enable_if_c<
conversion::implicit_converter<Target,Source>::value
, Target>::type
- implicit_convert_to(const Source& from, dummy::type_tag<Target> const&)
+ implicit_convert_to(const Source& from,
+ dummy::type_tag<Target> const&)
{
return conversion::implicit_converter<Target,Source>()(from);
}
@@ -129,7 +130,7 @@
} // namespace conversion
} // namespace boost
-#include <boost/conversion/is_extrinsically_convertible_tagged.hpp>
+#include <boost/conversion/detail/is_extrinsically_convertible_tagged.hpp>
namespace boost {
namespace conversion {
@@ -148,15 +149,15 @@
//!
//! @Example
//! @code
- //! Target t;
- //! Source s;
- //! t=boost::conversion::implicit_convert_to<Target>(s);
+ //! Target t;
+ //! Source s;
+ //! t=boost::conversion::implicit_convert_to<Target>(s);
//! @endcode
template <typename Target, typename Source>
typename enable_if_c<
is_extrinsically_convertible_tagged<Source, Target>::value
, Target>::type
- implicit_convert_to(Source const& from)
+ implicit_convert_to(const Source& from)
{
using namespace boost::conversion::impl_2;
//use boost::conversion::impl_2::implicit_convert_to if ADL fails
Modified: sandbox/conversion/boost/conversion/include.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/include.hpp (original)
+++ sandbox/conversion/boost/conversion/include.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -11,7 +11,7 @@
/*!
@file
@brief
-Include all the core conversion public header files. Note that you will need to include explicitly the C++ standard or Boost specific files when using specific classes.
+Includes all the core conversion public header files. Note that you will need to include explicitly the C++ standard or Boost specific files when using specific classes.
*/
#ifndef BOOST_CONVERSION_INCLUDE_HPP
Modified: sandbox/conversion/boost/conversion/is_extrinsically_assignable.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_assignable.hpp (original)
+++ sandbox/conversion/boost/conversion/is_extrinsically_assignable.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -12,33 +12,212 @@
* @brief Defines the type trait @c is_extrinsically_assignable.
*/
-
#ifndef BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_HPP
#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_HPP
-#include <boost/conversion/assign_to.hpp>
-
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
namespace boost {
namespace conversion {
+ /**
+ * States if @c Target is extrinsically assignable from @c Source.
+ *
+ * Condition: @c true_type if and only if the return expression in the following code
+ * would be well-formed:
+ * @code
+ * assign_to(declval<Target>(), declval<Source>()); }
+ * @endcode
+ * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+ *
+ */
+ template <typename Target, typename Source>
+ struct is_extrinsically_assignable {};
- /**
- * States if @c Target is extrinsically assignable from @c Source.
- *
- * Condition: @c true_type if and only if the return expression in the following code
- * would be well-formed:
- * @code
- * assign_to(declval<Target>(), declval<Source>()); }
- * @endcode
- *
- * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
- *
- */
- template <class Target, class Source>
- struct is_extrinsically_assignable : conversion::assigner<Target, Source> {};
+ //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_assignable type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
}
}
+#else
+
+
+#include <boost/conversion/config.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/common_type.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/conversion/assign_to.hpp>
+
+#if ! defined BOOST_NO_DECLTYPE
+ #if defined _MSC_VER
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
+ #endif
+ #elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
+ #endif
+ #else
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_DECLTYPE
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
+ #endif
+ #else
+#error
+ //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_DECLTYPE
+ //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined _MSC_VER
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+#elif defined __clang__
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
+#endif
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_USES_RVALUE
+ #endif
+#endif
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ namespace is_extrinsically_assignable {
+ template <typename T, typename S,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_assignable<T,S>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_DECLTYPE
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template <typename T1, typename S1>
+ static decltype((
+ ::boost::conversion::assign_to(declval<T1>(), declval<S1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_USES_RVALUE
+ selector(T1&&, S1&&);
+ #else
+ selector(T1&, S1&);
+ #endif
+
+ template <typename T1, typename S1>
+ static false_type
+ selector(any,any);
+
+ typedef typename common_type<decltype(selector(declval<T>(), declval<S>()))>::type type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_USES_SIZEOF
+
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template<typename T1, typename S1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ ::boost::conversion::assign_to(declval<T1>(), declval<S1>()) // EXPR
+ )
+ >*);
+
+ template<typename T1, typename S1>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<T,S>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ : public conversion::is_extrinsically_assignable_tagged<T,S> {};
#endif
+ template <typename T, typename S, bool B>
+ struct imp<T, S, true, B>
+ : public true_type {};
+
+ template <typename T,typename S, bool B>
+ struct imp<T, S, B, true>
+ : public false_type {};
+
+ } // is_extrinsically_assignable
+ } // detail
+
+ template <typename Target, typename Source>
+ struct is_extrinsically_assignable
+ : public detail::is_extrinsically_assignable::imp<Target, Source> {};
+
+ namespace detail {
+ namespace is_extrinsically_assignable {
+ template <typename T, typename S, std::size_t N>
+ struct imp<T[N],S[N],false,false>
+ : public conversion::is_extrinsically_assignable<T,S> {};
+ template <typename T, typename S, std::size_t N>
+ struct imp<T[N],S,false,false>
+ : public false_type {};
+ template <typename T, typename S, std::size_t N>
+ struct imp<T,S[N],false,false>
+ : public false_type {};
+ template <typename T, typename S>
+ struct imp<T[],S[],false,false>
+ : public false_type {};
+ template <typename T, typename S>
+ struct imp<T[],S,false,false>
+ : public false_type {};
+ template <typename T, typename S>
+ struct imp<T,S[],false,false>
+ : public false_type {};
+ } // is_extrinsically_assignable
+ } // detail
+ } // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Deleted: sandbox/conversion/boost/conversion/is_extrinsically_assignable_tagged.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_assignable_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,235 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
-//
-// See http://www.boost.org/libs/conversion for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-/**
- * @file
- * @brief Defines the type trait @c is_extrinsically_assignable_tagged.
- */
-
-#ifndef BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_HPP
-#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_HPP
-
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-namespace boost {
- namespace conversion {
- /**
- * States if @c Source is extrinsically assignable to @c Target.
- *
- * Condition: @c true_type if and only if the return expression in the following code
- * would be well-formed:
- * @code
- * Target test() { return implicit_convert_to<Target>(declval<Source>()); }
- * @endcode
- *
- * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
- *
- */
- template <class Source, class Target>
- struct is_extrinsically_assignable_tagged {};
-
- //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_assignable type trait for classes.
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
-
- }
-}
-#else
-
-
-#include <boost/conversion/config.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/common_type.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_function.hpp>
-
-#include <boost/utility/declval.hpp>
-#include <boost/conversion/assign_to.hpp>
-
-
-#if ! defined BOOST_NO_DECLTYPE
- #if defined _MSC_VER
- #if ! defined BOOST_NO_SFINAE_EXPR
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
- #endif
- #elif defined __clang__
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #if ! defined BOOST_NO_SFINAE_EXPR
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
- #endif
- #else
- //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
- //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
- #endif
- #else
-#error
- //#define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
- //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
- #endif
-#elif ! defined BOOST_NO_SFINAE_EXPR
- #if defined _MSC_VER
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
-#elif defined __clang__
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
- #elif defined __GNUC__
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
- #else
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
- #endif
-#else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE_TAGGED
-#endif
-
-#if ! defined BOOST_NO_RVALUE_REFERENCES
- #if defined _MSC_VER
- #elif defined __clang__
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
- #endif
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
- #endif
-#endif
-
-namespace boost {
- namespace conversion {
- namespace detail_is_extrinsically_assignable_tagged {
- using namespace boost::conversion_impl_2;
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class S, class T,
- bool True =
- (is_void<S>::value && is_void<T>::value)
- || ((is_scalar<T>::value || is_reference<T>::value) && is_assignable<S,T>::value)
- ,
- bool False =
- (is_void<S>::value && !is_void<T>::value)
- || (!is_void<S>::value && is_void<T>::value)
- || is_abstract<T>::value
- || is_function<T>::value >
- struct imp;
-
-#if defined BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_DECLTYPE
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template <class S1, class T1>
- static decltype((
- assign_to(declval<S1>(), declval<T1>()) // EXPR
- , true_type()))
- #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_RVALUE
- selector(S1&&, T1&&);
- #else
- selector(S1&, T1&);
- #endif
-
- template <class S1, class T1>
- static false_type
- selector(any,any);
-
- typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
- };
-
-#elif defined BOOST_CONVERSION_IS_EXTRINSIC_ASSIGNABLE_TAGGED_USES_SIZEOF
-
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template<class X, class Y>
- static detail_is_extrinsically_assignable_tagged::yes_type
- selector(detail_is_extrinsically_assignable_tagged::dummy<
- sizeof(
- assign_to(declval<S1>(), declval<T1>()) // EXPR
- )
- >*);
-
- template<class X, class Y>
- static detail_is_extrinsically_assignable_tagged::no_type
- selector(...);
-
- static const bool value =
- sizeof(selector<S,T>(0)) ==
- sizeof(detail_is_extrinsically_assignable_tagged::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
-
-#else
- template <class S,class T>
- struct imp<S,T,false,false>
- : public conversion::assigner<T,S> {};
-#endif
-// template <class S, class T, std::size_t N>
-// struct imp<S[N],T[N],false,false>
-// : public false_type {};
-// template <class S, class T, std::size_t N>
-// struct imp<S[N],T,false,false>
-// : public false_type {};
-// template <class S, class T, std::size_t N>
-// struct imp<S,T[N],false,false>
-// : public false_type {};
-// template <class S, class T>
-// struct imp<S[],T[],false,false>
-// : public false_type {};
-// template <class S, class T>
-// struct imp<S[],T,false,false>
-// : public false_type {};
-// template <class S, class T>
-// struct imp<S,T[],false,false>
-// : public false_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, true,B>
- : public true_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, B,true>
- : public false_type {};
-
- } // detail
-
-
- template <class Source, class Target>
- struct is_extrinsically_assignable_tagged
- : public detail_is_extrinsically_assignable_tagged::imp<Source, Target> {};
-
-} // conversion
-} // boost
-
-#endif // doc
-
-#endif // header
-
Modified: sandbox/conversion/boost/conversion/is_extrinsically_convertible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_convertible.hpp (original)
+++ sandbox/conversion/boost/conversion/is_extrinsically_convertible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -30,7 +30,7 @@
* @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
*
*/
- template <class Source, class Target>
+ template <typename Source, typename Target>
struct is_extrinsically_convertible {};
//! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_convertible type trait for classes.
@@ -54,10 +54,6 @@
#include <boost/conversion/type_traits/is_convertible.hpp>
#include <boost/conversion/implicit_convert_to.hpp>
-#if ! defined BOOST_CONVERSION_USES_SFINAE
-//#if 0
-#define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE
-#else
#if ! defined BOOST_NO_DECLTYPE
#if defined _MSC_VER
#if ! defined BOOST_NO_SFINAE_EXPR
@@ -68,7 +64,7 @@
#elif defined __clang__
#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_USES_DECLTYPE
#elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
#if ! defined BOOST_NO_SFINAE_EXPR
#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_USES_SIZEOF
#else
@@ -88,7 +84,6 @@
#else
#define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE
#endif
-#endif
#if ! defined BOOST_NO_RVALUE_REFERENCES
#if defined _MSC_VER
@@ -106,121 +101,109 @@
namespace boost {
namespace conversion {
+ namespace detail {
+ namespace is_extrinsically_convertible {
- namespace detail_is_extrinsically_convertible {
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class S, class T,
- bool True =
- (is_void<S>::value && is_void<T>::value)
- || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
- ,
- bool False =
- (is_void<S>::value && !is_void<T>::value)
- || (!is_void<S>::value && is_void<T>::value)
- || is_abstract<T>::value
- || is_function<T>::value
- >
- struct imp;
+ template <typename S, typename T,
+ bool True =
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
+ ,
+ bool False =
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value
+ >
+ struct imp;
#if defined BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_USES_DECLTYPE
#error
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template <class S1, class T1>
- static decltype((
- ::boost::conversion::implicit_convert_to<T1>(declval<S1>()) // EXPR
- , true_type()))
- #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
- selector(S1&&, T1&&);
- #else
- selector(S1&, T1&);
- #endif
-
- template <class S1, class T1>
- static false_type
- selector(any,any);
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template <typename S1, typename T1>
+ static decltype((
+ ::boost::conversion::implicit_convert_to<T1>(declval<S1>()) // EXPR
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
+ selector(S1&&, T1&&);
+ #else
+ selector(S1&, T1&);
+ #endif
+
+ template <typename S1, typename T1>
+ static false_type
+ selector(any,any);
- typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
- };
+ typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
+ };
#elif defined BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_USES_SIZEOF
-#error
-
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template<class X, class Y>
- static detail_is_extrinsically_convertible::yes_type
- selector(detail_is_extrinsically_convertible::dummy<
- sizeof(
- ::boost::conversion::implicit_convert_to<T1>(declval<S1>()) // EXPR
- )
- >*);
- template<class X, class Y>
- static detail_is_extrinsically_convertible::no_type
- selector(...);
-
- static const bool value =
- sizeof(selector<S,T>(0)) ==
- sizeof(detail_is_extrinsically_convertible::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ {
+ template<typename S1, typename T1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ ::boost::conversion::implicit_convert_to<T1>(declval<S1>()) // EXPR
+ )
+ >*);
+
+ template<typename X, typename Y>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
#else
- template <class S, class T>
- struct imp<S,T,false,false>
- : public is_extrinsically_convertible_tagged<S,T> {};
-#endif
- template <class S, class T, std::size_t N>
- struct imp<S[N],T[N],false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S[N],T,false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S,T[N],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T[],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T,false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S,T[],false,false>
- : public false_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, true,B>
- : public true_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, B,true>
- : public false_type {};
- }
+ template <typename S, typename T>
+ struct imp<S,T,false,false>
+ : public conversion::is_extrinsically_convertible_tagged<S,T> {};
+#endif
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S[N],T,false,false>
+ : public false_type {};
+ template <typename S, typename T, std::size_t N>
+ struct imp<S,T[N],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T[],false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S[],T,false,false>
+ : public false_type {};
+ template <typename S, typename T>
+ struct imp<S,T[],false,false>
+ : public false_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, true,B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<S, T, B,true>
+ : public false_type {};
+ } // is_extrinsically_convertible
+ } // detail
+
+ template <typename Source, typename Target>
+ struct is_extrinsically_convertible
+ : public detail::is_extrinsically_convertible::imp<Source, Target> {};
- template <class Source, class Target>
- struct is_extrinsically_convertible
- : public detail_is_extrinsically_convertible::imp<Source, Target> {};
+ template <typename T>
+ struct is_extrinsically_convertible<fusion::void_,T> : false_type {};
- template <class T>
- struct is_extrinsically_convertible<fusion::void_,T> : false_type {};
-
- }
-}
+ } // conversion
+} // boost
#endif
Deleted: sandbox/conversion/boost/conversion/is_extrinsically_convertible_tagged.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_convertible_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,236 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
-//
-// See http://www.boost.org/libs/conversion for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-/**
- * @file
- * @brief Defines the type trait @c is_extrinsically_convertible_tagged.
- */
-
-#ifndef BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_HPP
-#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_HPP
-
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-namespace boost {
- namespace conversion {
- /**
- * States if @c Source is extrinsically explicit convertible to @c Target.
- *
- * Condition: @c true_type if and only if the return expression in the following code
- * would be well-formed:
- * @code
- * Target test() { return implicit_convert_to<Target>(declval<Source>()); }
- * @endcode
- *
- * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
- *
- */
- template <class Source, class Target>
- struct is_extrinsically_convertible_tagged {};
-
- //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_convertible type trait for classes.
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
-
- }
-}
-#else
-
-
-#include <boost/conversion/config.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/common_type.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_function.hpp>
-
-#include <boost/utility/declval.hpp>
-#include <boost/conversion/implicit_convert_to.hpp>
-
-
-#if ! defined BOOST_NO_DECLTYPE
- #if defined _MSC_VER
- #if ! defined BOOST_NO_SFINAE_EXPR
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
- #endif
- #elif defined __clang__
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #if ! defined BOOST_NO_SFINAE_EXPR
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
- #endif
- #else
- //#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
- //#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
- #endif
- #else
-#error
- //#define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
- //#define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
- #endif
-#elif ! defined BOOST_NO_SFINAE_EXPR
- #if defined _MSC_VER
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
-#elif defined __clang__
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
- #elif defined __GNUC__
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
- #else
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
- #endif
-#else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_CONVERTIBLE_TAGGED
-#endif
-
-#if ! defined BOOST_NO_RVALUE_REFERENCES
- #if defined _MSC_VER
- #elif defined __clang__
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
- #endif
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
- #endif
-#endif
-
-namespace boost {
- namespace conversion {
- //namespace impl_2 {}
- namespace detail_is_extrinsically_convertible_tagged {
- using namespace boost::conversion::impl_2;
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class S, class T,
- bool True =
- (is_void<S>::value && is_void<T>::value)
- || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
- ,
- bool False =
- (is_void<S>::value && !is_void<T>::value)
- || (!is_void<S>::value && is_void<T>::value)
- || is_abstract<T>::value
- || is_function<T>::value >
- struct imp;
-
-#if defined BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_DECLTYPE
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template <class S1, class T1>
- static decltype((
- implicit_convert_to(declval<S1>(), conversion::dummy::type_tag<T1>()) // EXPR
- , true_type()))
- #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_RVALUE
- selector(S1&&, T1&&);
- #else
- selector(S1&, T1&);
- #endif
-
- template <class S1, class T1>
- static false_type
- selector(any,any);
-
- typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
- };
-
-#elif defined BOOST_CONVERSION_IS_EXTRINSIC_CONVERTIBLE_TAGGED_USES_SIZEOF
-
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template<class X, class Y>
- static detail_is_extrinsically_convertible_tagged::yes_type
- selector(detail_is_extrinsically_convertible_tagged::dummy<
- sizeof(
- implicit_convert_to(declval<X>(), conversion::dummy::type_tag<Y>()) // EXPR
- )
- >*);
-
- template<class X, class Y>
- static detail_is_extrinsically_convertible_tagged::no_type
- selector(...);
-
- static const bool value =
- sizeof(selector<S,T>(0)) ==
- sizeof(detail_is_extrinsically_convertible_tagged::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
-
-#else
- template <class S,class T>
- struct imp<S,T,false,false>
- : public conversion::implicit_converter<T,S> {};
-#endif
- template <class S, class T, std::size_t N>
- struct imp<S[N],T[N],false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S[N],T,false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S,T[N],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T[],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T,false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S,T[],false,false>
- : public false_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, true,B>
- : public true_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, B,true>
- : public false_type {};
-
- } // detail
-
-
- template <class Source, class Target>
- struct is_extrinsically_convertible_tagged
- : public detail_is_extrinsically_convertible_tagged::imp<Source, Target> {};
-
-} // conversion
-} // boost
-
-#endif // doc
-
-#endif // header
-
Modified: sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible.hpp (original)
+++ sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -40,7 +40,6 @@
}
#else
-
#include <boost/conversion/config.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/common_type.hpp>
@@ -54,9 +53,6 @@
#include <boost/conversion/explicit_convert_to.hpp>
#include <boost/conversion/type_traits/is_convertible.hpp>
-#if ! defined BOOST_CONVERSION_USES_SFINAE
-#define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE
-#else
#if ! defined BOOST_NO_DECLTYPE
#if defined _MSC_VER
#if ! defined BOOST_NO_SFINAE_EXPR
@@ -67,7 +63,7 @@
#elif defined __clang__
#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
#elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
#if ! defined BOOST_NO_SFINAE_EXPR
#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
#else
@@ -87,7 +83,6 @@
#else
#define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE
#endif
-#endif
#if ! defined BOOST_NO_RVALUE_REFERENCES
#if defined _MSC_VER
@@ -105,119 +100,120 @@
namespace boost {
namespace conversion {
- namespace detail_is_extrinsically_explicit_convertible {
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class S, class T,
- bool True =
- ((
- (is_void<S>::value && is_void<T>::value)
- || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
- ))
- ,
- bool False =
- ((
- (is_void<S>::value && !is_void<T>::value)
- || (!is_void<S>::value && is_void<T>::value)
- || is_abstract<T>::value
- || is_function<T>::value
- ))
- >
- struct imp;
-#if defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
-#error
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template <class S1, class T1>
- static decltype((
- ::boost::conversion::explicit_convert_to<T1>(declval<S1>()) // EXPR
- , true_type()))
- #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
- selector(S1&&, T1&&);
- #else
- selector(S1&, T1&);
- #endif
-
- template <class S1, class T1>
- static false_type
- selector(any,any);
+ namespace detail {
+ namespace is_extrinsically_explicit_convertible {
- typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
- };
-#elif defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
+ template <class S, class T,
+ bool True =
+ ((
+ (is_void<S>::value && is_void<T>::value)
+ || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
+ ))
+ ,
+ bool False =
+ ((
+ (is_void<S>::value && !is_void<T>::value)
+ || (!is_void<S>::value && is_void<T>::value)
+ || is_abstract<T>::value
+ || is_function<T>::value
+ ))
+ >
+ struct imp;
+#if defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
#error
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template<class X, class Y>
- static detail_is_extrinsically_explicit_convertible::yes_type
- selector(detail_is_extrinsically_explicit_convertible::dummy<
- sizeof(
+ template <class S, class T>
+ struct imp<S,T,false,false>
+ {
+ template <class S1, class T1>
+ static decltype((
::boost::conversion::explicit_convert_to<T1>(declval<S1>()) // EXPR
- )
- >*);
+ , true_type()))
+ #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
+ selector(S1&&, T1&&);
+ #else
+ selector(S1&, T1&);
+ #endif
+
+ template <class S1, class T1>
+ static false_type
+ selector(any,any);
- template<class X, class Y>
- static detail_is_extrinsically_explicit_convertible::no_type
- selector(...);
-
- static const bool value =
- sizeof(selector<S,T>(0)) ==
- sizeof(detail_is_extrinsically_explicit_convertible::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
+ typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
+ };
+#elif defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
+ template <class S, class T>
+ struct imp<S,T,false,false>
+ {
+ template <class S1, class T1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ ::boost::conversion::explicit_convert_to<T1>(declval<S1>()) // EXPR
+ )
+ >*);
+
+ template<class X, class Y>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<S,T>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
#else
- template <class S, class T>
- struct imp<S,T,false,false>
- : public is_extrinsically_explicit_convertible_tagged<S,T> {};
+ template <class S, class T>
+ struct imp<S,T,false,false>
+ : public conversion::is_extrinsically_explicit_convertible_tagged<S,T> {};
#endif
- template <class S, class T, std::size_t N>
- struct imp<S[N],T[N],false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S[N],T,false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S,T[N],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T[],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T,false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S,T[],false,false>
- : public false_type {};
-
- template <class S,class T, bool B>
- struct imp<S, T, true,B>
- : public true_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, B,true>
- : public false_type {};
- }
+ template <class S, class T, std::size_t N>
+ struct imp<S[N],T[N],false,false>
+ : public false_type {};
+ template <class S, class T, std::size_t N>
+ struct imp<S[N],T,false,false>
+ : public false_type {};
+ template <class S, class T, std::size_t N>
+ struct imp<S,T[N],false,false>
+ : public false_type {};
+ template <class S, class T>
+ struct imp<S[],T[],false,false>
+ : public false_type {};
+ template <class S, class T>
+ struct imp<S[],T,false,false>
+ : public false_type {};
+ template <class S, class T>
+ struct imp<S,T[],false,false>
+ : public false_type {};
+ template <class S, std::size_t N>
+ struct imp<S[N],S*,false,false>
+ : public true_type {};
+ template <class S, std::size_t N>
+ struct imp<S[N],const S*,false,false>
+ : public true_type {};
+ template <class S, std::size_t N>
+ struct imp<const S[N],S*,false,false>
+ : public false_type {};
+ template <class S, std::size_t N>
+ struct imp<const S[N],const S*,false,false>
+ : public true_type {};
+
+ template <class S,class T, bool B>
+ struct imp<S, T, true,B>
+ : public true_type {};
+
+ template <class S,class T,bool B>
+ struct imp<S, T, B,true>
+ : public false_type {};
+ } // is_extrinsically_explicit_convertible
+ } // detail
+
+ template <class Source, class Target>
+ struct is_extrinsically_explicit_convertible
+ : public detail::is_extrinsically_explicit_convertible::imp<Source, Target> {};
- template <class Source, class Target>
- struct is_extrinsically_explicit_convertible
- : public detail_is_extrinsically_explicit_convertible::imp<Source, Target> {};
-
- template <class T>
- struct is_extrinsically_explicit_convertible<fusion::void_,T> : false_type {};
-}
+ template <class T>
+ struct is_extrinsically_explicit_convertible<fusion::void_,T> : false_type {};
+ }
}
#endif // doc
Deleted: sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible2.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible2.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,213 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
-//
-// See http://www.boost.org/libs/conversion for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-/**
- * @file
- * @brief Defines the type trait @c is_extrinsically_explicit_convertible.
- */
-
-#ifndef BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_HPP
-#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_HPP
-
-
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-namespace boost {
- namespace conversion {
- /**
- * States if @c Source is extrinsically explicit convertible to @c Target.
- *
- * Condition: @c true_type if and only if the return expression in the following code
- * would be well-formed:
- * @code
- * Target test() { return explicit_convert_to<Target>(declval<Source>()); }
- * @endcode
- *
- * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
- *
- */
- template <class Source, class Target>
- struct is_extrinsically_explicit_convertible {};
-
- //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible type trait for classes.
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE
-
- }
-}
-#else
-
-
-#include <boost/config.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/common_type.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/fusion/tuple.hpp>
-#include <boost/conversion/explicit_convert_to.hpp>
-
-#if ! defined BOOST_NO_DECLTYPE
- #if defined _MSC_VER
- #if ! defined BOOST_NO_SFINAE_EXPR
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE
- #endif
- #elif defined __clang__
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #if ! defined BOOST_NO_SFINAE_EXPR
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE
- #endif
- #else
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
- #endif
- #else
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
- #endif
-#elif ! defined BOOST_NO_SFINAE_EXPR
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
- #if defined __clang__
- #elif defined __GNUC__
- #endif
-#else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE
-#endif
-
-#if ! defined BOOST_NO_RVALUE_REFERENCES
- #if defined _MSC_VER
- #elif defined __clang__
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_RVALUE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_RVALUE
- #endif
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_RVALUE
- #endif
-#endif
-
-namespace boost {
- namespace conversion {
- namespace detail_is_extrinsically_explicit_convertible {
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class U>
- struct test
- {
- U u;
- };
- template <class T, class S, bool BothVoid = is_void<T>::value && is_void<S>::value, bool BothNonVoid = !is_void<T>::value && !is_void<S>::value >
- struct imp;
-#if defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_DECLTYPE
-
- template <class T, class S>
- decltype((boost::conversion::explicit_convert_to<T>(declval<test<S> >()), true_type()))
- #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_RVALUE
- selector(T&&, S&&);
- #else
- selector(T&, S&);
- #endif
-
- false_type
- selector(any);
-
- template <class T, class S>
- struct imp<T,S,false,true>
- : public common_type<decltype(selector(declval<T>(), declval<S>()))>::type {};
-
-#elif defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_USES_SIZEOF
-
- template <class T, class S>
- struct imp<T,S,false,true>
- {
- template<class X, class Y>
- static detail_is_extrinsically_explicit_convertible::yes_type
- selector(detail_is_extrinsically_explicit_convertible::dummy<sizeof(boost::conversion::explicit_convert_to<X>(
- declval<Y>()))>*);
-
- template<class X, class Y>
- static detail_is_extrinsically_explicit_convertible::no_type
- selector(...);
-
- static const bool value =
- sizeof(selector<T,S>(0)) == sizeof(detail_is_extrinsically_explicit_convertible::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
-
-#else
- template <class T>
- struct imp<T,S,false,true>
- : public false_type {};
-#endif
- template <class T,class S>
- struct imp<T, S, true,false>
- : public true_type {};
-
- template <class T,class S>
- struct imp<T, S, false,false>
- : public false_type {};
-
- }
-
-
- template <class Source, class Target>
- struct is_extrinsically_explicit_convertible
- : public detail_is_extrinsically_explicit_convertible::imp<Source, Target> {};
-
- template <class T>
- struct is_extrinsically_explicit_convertible<fusion::void_,T> : false_type {};
-}
-}
-
-#endif // doc
-
-#if 0
-#include <boost/fusion/tuple.hpp>
-
-namespace boost {
- namespace conversion {
-
- template <class Source, class Target>
- struct is_extrinsically_explicit_convertible : conversion::explicit_converter<Target, Source> {};
-#if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
- template <class T>
- struct is_extrinsically_explicit_convertible<fusion::void_,T> : false_type {};
- template <>
- struct is_extrinsically_explicit_convertible<void, void> : true_type {};
- template <>
- struct is_extrinsically_explicit_convertible<const void,void> : true_type {};
- template <>
- struct is_extrinsically_explicit_convertible<void, const void> : true_type {};
- template <>
- struct is_extrinsically_explicit_convertible<const void, const void> : true_type {};
-#endif
-
- }
-}
-#endif
-
-
-#endif
-
Deleted: sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible_tagged.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible_tagged.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,231 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
-//
-// See http://www.boost.org/libs/conversion for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-/**
- * @file
- * @brief Defines the type trait @c is_extrinsically_explicit_convertible.
- */
-
-#ifndef BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_HPP
-#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_HPP
-
-
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-namespace boost {
- namespace conversion {
- /**
- * States if @c Source is extrinsically explicit convertible to @c Target.
- *
- * Condition: @c true_type if and only if the return expression in the following code
- * would be well-formed:
- * @code
- * Target test() { return explicit_convert_to<Target>(declval<Source>()); }
- * @endcode
- *
- * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
- *
- */
- template <class Source, class Target>
- struct is_extrinsically_explicit_convertible_tagged {};
-
- //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible type trait for classes.
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
-
- }
-}
-#else
-
-
-#include <boost/conversion/config.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/common_type.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/conversion/explicit_convert_to.hpp>
-#include <boost/conversion/type_traits/is_convertible.hpp>
-
-#if ! defined BOOST_NO_DECLTYPE
- #if defined _MSC_VER
- #if ! defined BOOST_NO_SFINAE_EXPR
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
- #endif
- #elif defined __clang__
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #if ! defined BOOST_NO_SFINAE_EXPR
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
- #endif
- #else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
- //#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
- #endif
- #else
-#error
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
- #endif
-#elif ! defined BOOST_NO_SFINAE_EXPR
- #if defined __clang__
-#error
-#define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
- #elif defined __GNUC__
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
- #else
- #error
- #define BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
- #endif
-#else
- #define BOOST_CONVERSION_NO_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED
-#endif
-
-#if ! defined BOOST_NO_RVALUE_REFERENCES
- #if defined _MSC_VER
- #elif defined __clang__
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
- #endif
- #else
- #define BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
- #endif
-#endif
-
-namespace boost {
- namespace conversion {
- namespace impl_2 {}
- namespace detail_is_extrinsically_explicit_convertible_tagged {
- using namespace boost::conversion::impl_2;
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class S, class T,
- bool True =
- (is_void<S>::value && is_void<T>::value)
- || ((is_scalar<T>::value || is_reference<T>::value) && is_convertible<S,T>::value)
- ,
- bool False =
- (is_void<S>::value && !is_void<T>::value)
- || (!is_void<S>::value && is_void<T>::value)
- || is_abstract<T>::value
- || is_function<T>::value
- >
- struct imp;
-
-#if defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_DECLTYPE
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template <class S1, class T1>
- static decltype((
- explicit_convert_to(declval<S1>(), conversion::dummy::type_tag<T1>()) // EXPR
- , true_type()))
- #if defined BOOST_CONVERSION_TT_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_RVALUE
- selector(S1&&, T1&&);
- #else
- selector(S1&, T1&);
- #endif
-
- template <class S1, class T1>
- static false_type
- selector(any,any);
-
- typedef typename common_type<decltype(selector(declval<S>(), declval<T>()))>::type type;
- };
-
-#elif defined BOOST_CONVERSION_IS_EXTRINSIC_EXPLICIT_CONVERTIBLE_TAGGED_USES_SIZEOF
-
- template <class S, class T>
- struct imp<S,T,false,false>
- {
- template<class X, class Y>
- static detail_is_extrinsically_explicit_convertible_tagged::yes_type
- selector(detail_is_extrinsically_explicit_convertible_tagged::dummy<
- sizeof(
- explicit_convert_to(declval<X>(), conversion::dummy::type_tag<Y>()) // EXPR
- )
- >*);
-
- template<class X, class Y>
- static detail_is_extrinsically_explicit_convertible_tagged::no_type
- selector(...);
-
- static const bool value =
- sizeof(selector<S,T>(0)) ==
- sizeof(detail_is_extrinsically_explicit_convertible_tagged::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
-
-#else
- template <class S, class T>
- struct imp<S,T,false,false>
- : public conversion::explicit_converter<T,S> {};
-#endif
- template <class S, class T, std::size_t N>
- struct imp<S[N],T[N],false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S[N],T,false,false>
- : public false_type {};
- template <class S, class T, std::size_t N>
- struct imp<S,T[N],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T[],false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S[],T,false,false>
- : public false_type {};
- template <class S, class T>
- struct imp<S,T[],false,false>
- : public false_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, true,B>
- : public true_type {};
-
- template <class S,class T,bool B>
- struct imp<S, T, B,true>
- : public false_type {};
-
- } // detail
-
-
- template <class Source, class Target>
- struct is_extrinsically_explicit_convertible_tagged
- : public detail_is_extrinsically_explicit_convertible_tagged::imp<Source, Target> {};
-
-} // conversion
-} // boost
-
-#endif // doc
-
-#endif // header
-
Modified: sandbox/conversion/boost/conversion/std/pair.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/pair.hpp (original)
+++ sandbox/conversion/boost/conversion/std/pair.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -37,7 +37,7 @@
/**
* Partial specialization of @c implicit_converter_cp for @c std::pair of extrinsic convertibles.
*/
- template < class T1, class T2, class S1, class S2>
+ template < typename T1, typename T2, typename S1, typename S2>
struct implicit_converter_cp< std::pair<T1,T2>, std::pair<S1,S2>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
@@ -61,7 +61,7 @@
/**
* Partial specialization of @c assigner_cp for @c std::pair of extrinsic convertibles.
*/
- template < class T1, class T2, class S1, class S2>
+ template < typename T1, typename T2, typename S1, typename S2>
struct assigner_cp< std::pair<T1,T2>, std::pair<S1,S2>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires(
Modified: sandbox/conversion/boost/conversion/std/vector.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/std/vector.hpp (original)
+++ sandbox/conversion/boost/conversion/std/vector.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -37,7 +37,7 @@
/**
* Partial specialization of @c implicit_converter_cp for @c std::vector of extrinsic convertibles.
*/
- template < class T1, class A1, class T2, class A2>
+ template < typename T1, typename A1, typename T2, typename A2>
struct implicit_converter_cp< std::vector<T1,A1>, std::vector<T2,A2>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires
@@ -65,7 +65,7 @@
/**
* Partial specialization of @c assigner_cp for @c std::vector of extrinsic convertibles.
*/
- template < class T1, class A1, class T2, class A2>
+ template < typename T1, typename A1, typename T2, typename A2>
struct assigner_cp< std::vector<T1,A1>, std::vector<T2,A2>
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
, requires
Modified: sandbox/conversion/boost/conversion/try_assign_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/try_assign_to.hpp (original)
+++ sandbox/conversion/boost/conversion/try_assign_to.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -12,42 +12,69 @@
@brief
Defines the free function @c try_assign_to and its customization point @c try_assigner.
-The function @c try_assign_to assigns the @c from parameter to the @c to parameter. Return @c true if assignment done and @c false otherwise.
-
+ The function @c try_assign_to assigns the @c from parameter to the @c to parameter. Return @c true if assignment done and @c false otherwise.
*/
#ifndef BOOST_CONVERSION_TRY_ASSIGN_TO_HPP
#define BOOST_CONVERSION_TRY_ASSIGN_TO_HPP
-/**
-The user can add the @c try_assign_to overloading on the namespace of the Source or Target classes.
-But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace,
-so we need a different technique.
-
-The technique consists in partially specialize on the function @c try_assign_to on the @c boost::conversion namespace.
-For compilers for which we can not partially specialize a function a trick is used:
-instead of calling directly to the @c try_assign_to member function, @c try_assign_to calls to the static operation apply
-on a class with the same name in the namespace @c overload_workaround.
-Thus the user can specialize partially this class.
-*/
-
-
+#include <boost/conversion/config.hpp>
#include <cstddef> //for std::size_t
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
+#include <boost/conversion/type_traits/is_default_constructible.hpp>
+#include <boost/conversion/type_traits/is_copy_constructible.hpp>
+#include <boost/conversion/type_traits/is_copy_assignable.hpp>
+#include <boost/conversion/is_extrinsically_assignable.hpp>
namespace boost {
namespace conversion {
+
//! Customization point for @c try_assign_to.
- //!
- //! @tparam Target target type of the conversion.
- //! @tparam Source source type of the conversion.
- //! @tparam Enable A dummy template parameter that can be used for SFINAE.
- //!
- //! This struct can be specialized by the user.
- template < typename Target, typename Source, class Enable = void >
- struct try_assigner
+ //!
+ //! @tparam Target target type of the conversion.
+ //! @tparam Source source type of the conversion.
+ //! @tparam Enable A dummy template parameter that can be used for SFINAE.
+ //!
+ //! This class must be specialized by the user when the default behavior of @c try_assign_to is not satisfying.
+ template < typename Target, typename Source, typename Enable = void >
+ struct try_assigner_cp : false_type {};
+
+ //! Default @c try_converter.
+ //!
+ //! @tparam Target target type of the conversion.
+ //! @tparam Source source type of the conversion.
+ //! @tparam Enable A dummy template parameter that can be used for SFINAE.
+ //!
+ //! The default implementation relies on the @c try_assigner_cp which must be specialized by the user.
+ template < typename Target, typename Source, typename Enable = void >
+ struct try_assigner : try_assigner_cp<Target,Source,Enable> {};
+
+ //! Specialization for @c try_assigner when @c is_extrinsically_explicit_convertible<Source,Target>.
+ //!
+ //! @tparam Target target type of the conversion.
+ //! @tparam Source source type of the conversion.
+ //!
+ //! @Requires @c is_extrinsically_explicit_convertible<Source,Target>
+
+
+ template < typename Target, typename Source >
+ struct try_assigner<Target, Source,
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ requires(
+ CopyConstructible<Target>
+ && CopyAssignable<Target>
+ && ExtrinsicallyAssignable<Target,Source>
+ )
+#else
+ typename enable_if_c<
+ is_copy_constructible<Target>::value
+ && is_copy_assignable<Target>::value
+ && is_extrinsically_assignable<Target,Source>::value
+ >::type
+#endif
+ > : true_type
{
//! @Requires @c Target must be CopyConstructible and @c ::boost::conversion::assign_to(to, from) must be well formed.
//! @Effects Converts the @c from parameter to the @c to parameter, using @c assign_to.
@@ -73,9 +100,23 @@
//! specialization for c-arrays
//!
template < typename Target, typename Source, std::size_t N >
- struct try_assigner<Target[N],Source[N]>
+ struct try_assigner<Target[N],Source[N],
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ requires(
+ DefaultConstructible<Target[N]>
+ && ExtrinsicallyAssignable<Target[N],Target[N]>
+ && ExtrinsicallyAssignable<Target,Source>
+ )
+#else
+ typename enable_if_c<
+ is_default_constructible<Target[N]>::value
+ && is_extrinsically_assignable<Target[N],Target[N]>::value
+ && is_extrinsically_assignable<Target,Source>::value
+ >::type
+#endif
+ > : true_type
{
- //! @Effects Converts the @c from parameter to the @c to parameter, using by default the assignment operator on each vector element.
+ //! @Effects Converts the @c from parameter to the @c to parameter, using by default the assignment operator on each vector element.
//! @NoThrow
//! @Returns the converted value if success or the fallback when conversion fails.
bool operator()(Target(&to)[N], const Source(& from)[N])
@@ -109,7 +150,10 @@
//! @Returns the converted value if success or the fallback when conversion fails.
//! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
template < typename Target, typename Source >
- bool try_assign_to(Target& to, const Source& from)
+ typename enable_if_c<
+ conversion::try_assigner<Target,Source>::value
+ , bool >::type
+ try_assign_to(Target& to, const Source& from)
{
return conversion::try_assigner<Target,Source>()(to, from);
}
@@ -125,7 +169,11 @@
}
}
#endif
+}
+#include <boost/conversion/detail/is_extrinsically_try_assignable_tagged.hpp>
+
+namespace boost {
namespace conversion {
//! @brief try to assign a target from a source
@@ -142,7 +190,10 @@
//! bool b = boost::conversion::try_assign_to(t,s);
//! @endcode
template <typename Target, typename Source>
- bool try_assign_to(Target& to, const Source& from)
+ typename enable_if_c<
+ is_extrinsically_try_assignable_tagged<Target, Source>::value
+ , bool >::type
+ try_assign_to(Target& to, const Source& from)
{
return conversion_impl::try_assign_to_impl<Target, Source>(to, from);
}
Modified: sandbox/conversion/boost/conversion/try_convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/try_convert_to.hpp (original)
+++ sandbox/conversion/boost/conversion/try_convert_to.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -14,40 +14,58 @@
The @c try_convert_to function converts the @c from parameter to a @c Target type and returns an optional<Target>, uninitialized if conversion fails.
-
*/
#ifndef BOOST_CONVERSION_TRY_CONVERT_TO_HPP
#define BOOST_CONVERSION_TRY_CONVERT_TO_HPP
-/**
- * A user adapting specific types could need to specialize the @c try_convert_to free function if the default behavior is not satisfactory or if the specialization can perform better.
-
- * A user adapting another type could need to overload the @c try_convert_to free function
- * if the default behavior is not satisfactory.
- * The user can add the @c try_convert_to overloading on any namespace found by ADL from the @c Source or the @c Target.
- * A trick is used to overload on the return type by adding a dummy parameter having the Target.
- *
- * But sometimes, as it is the case for the standard classes,
- * we can not add new functions on the @c std namespace, so we need a different technique.
- * In this case the user can partially specialize the @c boost::conversion::overload_workaround::try_convert_to struct.
-*/
-
+#include <boost/conversion/config.hpp>
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/boost/optional.hpp>
+#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/utility/enable_if.hpp>
namespace boost {
- namespace conversion {
+ namespace conversion {
//! Customization point for @c try_convert_to.
//!
//! @tparam Target target type of the conversion.
//! @tparam Source source type of the conversion.
//! @tparam Enable A dummy template parameter that can be used for SFINAE.
//!
- //! This struct can be specialized by the user.
- template < typename Target, typename Source, class Enable = void >
- struct try_converter {
- //! @Requires @c Target must be CopyConstructible and @c ::boost::conversion::convert_to<Target>(from) must be well formed.
+ //! This class must be specialized by the user when the default behavior of @c try_convert_to is not satisfying.
+ template < typename Target, typename Source, typename Enable = void >
+ struct try_converter_cp : false_type {};
+
+ //! Default @c try_converter.
+ //!
+ //! @tparam Target target type of the conversion.
+ //! @tparam Source source type of the conversion.
+ //! @tparam Enable A dummy template parameter that can be used for SFINAE.
+ //!
+ //! The default implementation relies on the @c try_converter_cp which must be specialized by the user.
+ template < typename Target, typename Source, typename Enable = void >
+ struct try_converter : try_converter_cp<Target,Source,Enable> {};
+
+ //! Specialization for @c try_converter when @c is_extrinsically_explicit_convertible<Source,Target>.
+ //!
+ //! @tparam Target target type of the conversion.
+ //! @tparam Source source type of the conversion.
+ //!
+ //! @Requires @c is_extrinsically_explicit_convertible<Source,Target>
+ template < typename Target, typename Source>
+ struct try_converter<Target, Source,
+#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
+ requires(ExtrinsicallyExplicitConvertible<Source,Target>)
+#else
+ typename enable_if_c<
+ is_extrinsically_explicit_convertible<Source,Target>::value
+ >::type
+#endif
+ > : true_type
+ {
+ //! @Requires @c ::boost::conversion::convert_to<Target>(from) must be well formed.
//! @Effects Converts the @c from parameter to an instance of the @c Target type, using by default the conversion operator or copy constructor.
//! @NoThrow
//! @Returns A optional<Ratget> uninitialized when conversion fails.
@@ -74,7 +92,10 @@
//! @Returns A optional<Target> uninitialized when conversion fails.
//! Forwards the call to the overload workaround, which can yet be specialized by the user for standard C++ types.
template < typename Target, typename Source >
- optional<Target> try_convert_to(const Source& from, dummy::type_tag<Target> const&) {
+ typename enable_if_c<
+ conversion::try_converter<Target,Source>::value
+ , optional<Target> >::type
+ try_convert_to(const Source& from, dummy::type_tag<Target> const&) {
return conversion::try_converter<Target,Source>()(from);
}
}
@@ -87,6 +108,13 @@
}
}
#endif
+ }
+}
+
+#include <boost/conversion/detail/is_extrinsically_try_convertible_tagged.hpp>
+
+namespace boost {
+ namespace conversion {
//! @tparam Target target type of the conversion.
//! @tparam Source source type of the conversion.
@@ -101,11 +129,13 @@
//! res=boost::conversion::try_convert_to<Target>(s);
//! @endcode
template <typename Target, typename Source>
- optional<Target> try_convert_to(Source const& from) {
+ typename enable_if_c<
+ is_extrinsically_try_convertible_tagged<Source,Target>::value
+ , optional<Target> >::type
+ try_convert_to(Source const& from) {
return boost::conversion::impl::try_convert_to_impl<Target>(from);
}
}
-
}
#endif
Modified: sandbox/conversion/boost/conversion/type_traits/boost/array.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/array.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/array.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -23,7 +23,7 @@
// These specializations are needed because the std library implementation is not using SFINAE
- template <class T1, class T2, std::size_t N>
+ template <typename T1, typename T2, std::size_t N>
struct is_assignable< boost::array<T1,N>, boost::array<T2,N> >
: integral_constant<bool, is_assignable<T1,T2>::value >
{};
Modified: sandbox/conversion/boost/conversion/type_traits/boost/chrono/duration.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/chrono/duration.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/chrono/duration.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -22,17 +22,17 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class Rep, class Period >
+ template < typename Rep, typename Period >
struct is_constructible< chrono::duration<Rep, Period> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class Rep, class Period >
+ template < typename Rep, typename Period >
struct is_constructible< chrono::duration<Rep, Period>, chrono::duration<Rep, Period> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class Rep, class Period >
+ template < typename Rep, typename Period >
struct is_assignable< chrono::duration<Rep, Period>&, chrono::duration<Rep, Period> const& > : true_type {};
- template < class Rep, class Period >
+ template < typename Rep, typename Period >
struct is_assignable< chrono::duration<Rep, Period>, chrono::duration<Rep, Period> > : true_type {};
#endif
Modified: sandbox/conversion/boost/conversion/type_traits/boost/chrono/time_point.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/chrono/time_point.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/chrono/time_point.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -22,17 +22,17 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class Clock, class Duration>
+ template < typename Clock, typename Duration>
struct is_constructible< chrono::time_point<Clock, Duration> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class Clock, class Duration>
+ template < typename Clock, typename Duration>
struct is_constructible< chrono::time_point<Clock, Duration>, chrono::time_point<Clock, Duration> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class Clock, class Duration>
+ template < typename Clock, typename Duration>
struct is_assignable< chrono::time_point<Clock, Duration>&, chrono::time_point<Clock, Duration> const& > : true_type {};
- template < class Clock, class Duration>
+ template < typename Clock, typename Duration>
struct is_assignable< chrono::time_point<Clock, Duration>, chrono::time_point<Clock, Duration> > : true_type {};
#endif
Modified: sandbox/conversion/boost/conversion/type_traits/boost/fusion/tuple.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/fusion/tuple.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/fusion/tuple.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -24,48 +24,48 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class T1, class T2, class T3 >
+ template < typename T1, typename T2, typename T3 >
struct is_constructible< fusion::tuple<T1,T2,T3> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class T1, class T2, class T3 >
+ template < typename T1, typename T2, typename T3 >
struct is_constructible< fusion::tuple<T1,T2,T3>, fusion::tuple<T1,T2,T3> > : true_type {};
#endif
// these specializations are needed because the libraries define the assignment operator without using SFINAE
// TODO Use PP library to manage with variadic templates
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_constructible< fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >
: integral_constant<bool, is_constructible<A1,B1>::value && is_constructible<A2,B2>::value >
{};
- template <class A1, class A2, class A3, class B1, class B2, class B3>
+ template <typename A1, typename A2, typename A3, typename B1, typename B2, typename B3>
struct is_constructible< fusion::tuple<A1,A2,A3>, fusion::tuple<B1,B2,B3> >
: integral_constant<bool, is_constructible<A1,B1>::value && is_constructible<A2,B2>::value&& is_constructible<A3,B3>::value >
{};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_explicitly_convertible< fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >
: integral_constant<bool, is_explicitly_convertible<A1,B1>::value && is_explicitly_convertible<A2,B2>::value >
{};
- template <class A1, class A2, class A3, class B1, class B2, class B3>
+ template <typename A1, typename A2, typename A3, typename B1, typename B2, typename B3>
struct is_explicitly_convertible< fusion::tuple<A1,A2,A3>, fusion::tuple<B1,B2,B3> >
: integral_constant<bool, is_explicitly_convertible<A1,B1>::value && is_explicitly_convertible<A2,B2>::value&& is_explicitly_convertible<A3,B3>::value >
{};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_assignable< fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >
: integral_constant<bool, is_assignable<A1,B1>::value && is_assignable<A2,B2>::value >
{};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_assignable< fusion::tuple<A1,A2>&, fusion::tuple<B1,B2> const&>
: integral_constant<bool, is_assignable<A1,B1>::value && is_assignable<A2,B2>::value >
{};
- template <class A1, class A2, class A3, class B1, class B2, class B3>
+ template <typename A1, typename A2, typename A3, typename B1, typename B2, typename B3>
struct is_assignable< fusion::tuple<A1,A2,A3>, fusion::tuple<B1,B2,B3> >
: integral_constant<bool, is_assignable<A1,B1>::value && is_assignable<A2,B2>::value&& is_assignable<A3,B3>::value >
{};
Modified: sandbox/conversion/boost/conversion/type_traits/boost/numeric/interval.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/numeric/interval.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/numeric/interval.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -22,17 +22,17 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class T, class P>
+ template < typename T, typename P>
struct is_constructible< numeric::interval<T,P> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class T, class P>
+ template < typename T, typename P>
struct is_constructible< numeric::interval<T,P>, numeric::interval<T,P> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class T, class P>
+ template < typename T, typename P>
struct is_assignable< numeric::interval<T,P>&, numeric::interval<T,P> const& > : true_type {};
- template < class T, class P>
+ template < typename T, typename P>
struct is_assignable< numeric::interval<T,P>, numeric::interval<T,P> > : true_type {};
#endif
Modified: sandbox/conversion/boost/conversion/type_traits/boost/optional.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/optional.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/optional.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -22,17 +22,17 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class T >
+ template < typename T >
struct is_constructible< optional<T> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class T >
+ template < typename T >
struct is_constructible< optional<T>, optional<T> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class T >
+ template < typename T >
struct is_assignable< optional<T>, optional<T> > : true_type {};
- template < class T >
+ template < typename T >
struct is_assignable< optional<T>&, optional<T> const& > : true_type {};
#endif
Modified: sandbox/conversion/boost/conversion/type_traits/boost/rational.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/boost/rational.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/boost/rational.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -22,17 +22,17 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class T>
+ template < typename T>
struct is_constructible< rational<T> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class T>
+ template < typename T>
struct is_constructible< rational<T>, rational<T> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class T>
+ template < typename T>
struct is_assignable< rational<T>, rational<T> > : true_type {};
- template < class T>
+ template < typename T>
struct is_assignable< rational<T>&, rational<T> const& > : true_type {};
#endif
Added: sandbox/conversion/boost/conversion/type_traits/detail/any.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/type_traits/detail/any.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the any type useful to catch any type on overloadin resolution.
+ */
+
+#ifndef BOOST_CONVERSION_TT_DETAIL_ANY_HPP
+#define BOOST_CONVERSION_TT_DETAIL_ANY_HPP
+
+namespace boost {
+ namespace type_traits {
+ namespace detail {
+ struct any {
+ template <typename T>
+ any(T);
+ };
+ } // detail
+ } // type_traits
+} // boost
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/type_traits/detail/dummy_size.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/type_traits/detail/dummy_size.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the dummy_size useful to to accept a sizeof as parameter.
+ */
+
+#ifndef BOOST_CONVERSION_TT_DETAIL_DUMMY_SIZE_HPP
+#define BOOST_CONVERSION_TT_DETAIL_DUMMY_SIZE_HPP
+
+namespace boost {
+ namespace type_traits {
+ namespace detail {
+ //! type useful to accept a sizeof as parameter
+ template <std::size_t N>
+ struct dummy_size;
+
+ } // detail
+ } // type_traits
+} // boost
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/type_traits/detail/nat.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/type_traits/detail/nat.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,28 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the any type useful to catch any type on overloadin resolution.
+ */
+
+#ifndef BOOST_CONVERSION_TT_DETAIL_NAT_HPP
+#define BOOST_CONVERSION_TT_DETAIL_NAT_HPP
+
+namespace boost {
+ namespace type_traits {
+ namespace detail {
+ //! not a type. used as default of variadic templates
+ struct nat {};
+ } // detail
+ } // type_traits
+} // boost
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/type_traits/detail/yes_no_types.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/type_traits/detail/yes_no_types.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,31 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2009-2011. 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)
+//
+// See http://www.boost.org/libs/conversion for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * @file
+ * @brief Defines the any type useful to catch any type on overload resolution.
+ */
+
+#ifndef BOOST_CONVERSION_TT_DETAIL_YES_NO_TYPES_HPP
+#define BOOST_CONVERSION_TT_DETAIL_YES_NO_TYPES_HPP
+
+namespace boost {
+ namespace type_traits {
+ namespace detail {
+ //! type useful to compare with the sizeof
+ typedef char yes_type;
+ //! type useful to compare with the sizeof
+ struct no_type { char a[2]; };
+
+ } // detail
+ } // type_traits
+} // boost
+
+#endif // header
+
Modified: sandbox/conversion/boost/conversion/type_traits/is_assignable.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_assignable.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_assignable.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -15,38 +15,6 @@
#ifndef BOOST_CONVERSION_TT_IS_ASSIGNABLE_HPP
#define BOOST_CONVERSION_TT_IS_ASSIGNABLE_HPP
-#include <boost/config.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
- //! Macro stating if the compiler don't support the features needed to define the @c is_assignable type trait.
- #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
-#else
- #if ! defined(BOOST_NO_DECLTYPE)
- #if defined _MSC_VER
- #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
- #elif defined __clang__
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
- #endif
- #else
- #endif
- #else
- #if defined _MSC_VER
- #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
- #elif defined __clang__
- //#define BOOST_CONVERSION_NO_IS_ASSIGNABLE
- #elif defined __GNUC__
- #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
- #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
- #endif
- #else
- #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
- #endif
- #endif
-#endif
-
#if defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
namespace boost {
@@ -58,207 +26,238 @@
*
* @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
*/
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct is_assignable
{};
+ //! Macro stating if the compiler don't support the features needed to define the @c is_assignable type trait.
+ #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
}
#else
+#include <boost/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
-#if !defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_ASSIGNABLE_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_ASSIGNABLE_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_ASSIGNABLE_USES_RVALUE
+ #endif
+#endif
+
+#if defined(BOOST_IS_ASSIGNABLE)
+#define BOOST_CONVERSION_IS_ASSIGNABLE_USES_INTRINSICS
+#elif ! defined(BOOST_NO_DECLTYPE)
+ #if defined _MSC_VER
+ #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
+ #elif defined __clang__
+ #error
+ #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_DECLTYPE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
+ #else
+ #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_DECLTYPE
+ #endif
+ #else
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined _MSC_VER
+ #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
+ #elif defined __clang__
+ #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
+#endif
-#include <boost/type_traits/intrinsics.hpp>
#if !defined(BOOST_IS_ASSIGNABLE)
+#include <boost/utility/enable_if.hpp>
+#include <boost/conversion/type_traits/detail/any.hpp>
+#include <boost/conversion/type_traits/detail/yes_no_types.hpp>
+#include <boost/conversion/type_traits/detail/dummy_size.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/common_type.hpp>
#include <boost/utility/declval.hpp>
-#if defined(BOOST_NO_DECLTYPE)
-#include <boost/typeof/typeof.hpp>
-#endif // defined(BOOST_NO_DECLTYPE)
#endif // !defined(BOOST_IS_ASSIGNABLE)
-
-
// should be always the last #include directive
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
#ifndef BOOST_IS_ASSIGNABLE
+ namespace type_traits {
+ namespace detail {
+ namespace is_assignable {
+ template <typename T,typename S,
+ bool True = false,
+ bool False = false >
+ struct imp;
+
+#if defined BOOST_CONVERSION_IS_ASSIGNABLE_USES_DECLTYPE
+
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template <typename T1, typename S1>
+ static decltype((
+ declval<T1>() = declval<S1>()
+ , true_type()))
+ selector(int);
+
+ template <typename T1, typename S1>
+ static false_type
+ selector(...);
+
+ typedef decltype(selector<T,S>(0)) type;
+ };
+
+#elif defined BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
+
+ template <typename T, typename S>
+ struct imp<T,S,false,false>
+ {
+ template<typename T1, typename S1>
+ static yes_type
+ selector(dummy_size<
+ sizeof(
+ declval<T1>() = declval<S1>()
+ )
+ >*);
+
+ template<typename T1, typename S1>
+ static no_type
+ selector(...);
+
+ static const bool value =
+ sizeof(selector<T,S>(0)) ==
+ sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+#else
+ template <typename T,typename S>
+ struct imp<T,S,false,false>
+ : public false_type {};
+
+ template <> struct imp< bool&, bool const&, false, false> : true_type {};
+
+ template <> struct imp< int&, int, false, false > : true_type {};
+ template <> struct imp< int&, int&, false, false > : true_type {};
+ template <> struct imp< int&, int const&, false, false > : true_type {};
+ template <> struct imp< int&, double, false, false > : true_type {};
+ template <> struct imp< int&, short const&, false, false > : true_type {};
+ template <> struct imp< short&, int const&, false, false > : true_type {};
+ template <> struct imp< float, int, false, false > : true_type {};
+ template <> struct imp< int, float, false, false > : true_type {};
+
+ template <> struct imp< char, char, false, false > : true_type {};
+ template <> struct imp< char, unsigned char, false, false > : true_type {};
+ template <> struct imp< char, short, false, false > : true_type {};
+ template <> struct imp< char, unsigned short, false, false > : true_type {};
+ template <> struct imp< char, int, false, false > : true_type {};
+ template <> struct imp< char, unsigned int, false, false > : true_type {};
+ template <> struct imp< char, long, false, false > : true_type {};
+ template <> struct imp< char, unsigned long, false, false > : true_type {};
+
+ template <> struct imp< char, char const&, false, false > : true_type {};
+ template <> struct imp< char, short const&, false, false > : true_type {};
+ template <> struct imp< char, int const&, false, false > : true_type {};
+ template <> struct imp< char, long const&, false, false > : true_type {};
+ template <> struct imp< char, unsigned char const&, false, false > : true_type {};
+ template <> struct imp< char, unsigned short const&, false, false > : true_type {};
+ template <> struct imp< char, unsigned int const&, false, false > : true_type {};
+ template <> struct imp< char, unsigned long const&, false, false > : true_type {};
+
+ template <> struct imp< short, char, false, false > : true_type {};
+ template <> struct imp< short, unsigned char, false, false > : true_type {};
+ template <> struct imp< short, short, false, false > : true_type {};
+ template <> struct imp< short, unsigned short, false, false > : true_type {};
+ template <> struct imp< short, int, false, false > : true_type {};
+ template <> struct imp< short, unsigned int, false, false > : true_type {};
+ template <> struct imp< short, long, false, false > : true_type {};
+ template <> struct imp< short, unsigned long, false, false > : true_type {};
+
+ template <> struct imp< short, char const&, false, false > : true_type {};
+ template <> struct imp< short, short const&, false, false > : true_type {};
+ template <> struct imp< short, int const&, false, false > : true_type {};
+ template <> struct imp< short, long const&, false, false > : true_type {};
+ template <> struct imp< short, unsigned char const&, false, false > : true_type {};
+ template <> struct imp< short, unsigned short const&, false, false > : true_type {};
+ template <> struct imp< short, unsigned int const&, false, false > : true_type {};
+ template <> struct imp< short, unsigned long const&, false, false > : true_type {};
+
+ template <> struct imp< int, char, false, false > : true_type {};
+ template <> struct imp< int, unsigned char, false, false > : true_type {};
+ template <> struct imp< int, short, false, false > : true_type {};
+ template <> struct imp< int, unsigned short, false, false > : true_type {};
+ template <> struct imp< int, int, false, false > : true_type {};
+ template <> struct imp< int, unsigned int, false, false > : true_type {};
+ template <> struct imp< int, long, false, false > : true_type {};
+ template <> struct imp< int, unsigned long, false, false > : true_type {};
+
+ template <> struct imp< int, char const&, false, false > : true_type {};
+ template <> struct imp< int, short const&, false, false > : true_type {};
+ template <> struct imp< int, int const&, false, false > : true_type {};
+ template <> struct imp< int, long const&, false, false > : true_type {};
+ template <> struct imp< int, unsigned char const&, false, false > : true_type {};
+ template <> struct imp< int, unsigned short const&, false, false > : true_type {};
+ template <> struct imp< int, unsigned int const&, false, false > : true_type {};
+ template <> struct imp< int, unsigned long const&, false, false > : true_type {};
+
+ template <> struct imp< long, char, false, false > : true_type {};
+ template <> struct imp< long, unsigned char, false, false > : true_type {};
+ template <> struct imp< long, short, false, false > : true_type {};
+ template <> struct imp< long, unsigned short, false, false > : true_type {};
+ template <> struct imp< long, int, false, false > : true_type {};
+ template <> struct imp< long, unsigned int, false, false > : true_type {};
+ template <> struct imp< long, long, false, false > : true_type {};
+ template <> struct imp< long, unsigned long, false, false > : true_type {};
+
+ template <> struct imp< long, char const&, false, false > : true_type {};
+ template <> struct imp< long, short const&, false, false > : true_type {};
+ template <> struct imp< long, int const&, false, false > : true_type {};
+ template <> struct imp< long, long const&, false, false > : true_type {};
+ template <> struct imp< long, unsigned char const&, false, false > : true_type {};
+ template <> struct imp< long, unsigned short const&, false, false > : true_type {};
+ template <> struct imp< long, unsigned int const&, false, false > : true_type {};
+ template <> struct imp< long, unsigned long const&, false, false > : true_type {};
+#endif
+
+ template <typename T,typename S,bool B>
+ struct imp<T, S, true, B>
+ : public true_type {};
+
+ template <typename S,typename T,bool B>
+ struct imp<T, S, B, true>
+ : public false_type {};
- namespace detail {
-
- namespace is_assignable {
-#if 0
-#ifdef BOOST_NO_SFINAE_EXPR
- typedef char yes_type;
- struct no_type { char a[2]; };
-
- template<std::size_t N>
- struct dummy;
-
- template <class Target, class Source>
- struct impl
- {
- Target t;
- template <typename X>
- static yes_type
- test(dummy<sizeof(declval<X>() = declval<Source>())>*);
-
- template <typename X>
- static no_type
- test(...);
- static const bool value = sizeof(test<Target>(0)) == sizeof(yes_type);
-
- typedef boost::integral_constant<bool,value> type;
- };
-#else // BOOST_NO_SFINAE_EXPR
- template <class Target, class Source>
- struct impl : false_type {};
-#endif // BOOST_NO_SFINAE_EXPR
-
-#else // 0
-
- template <class Target, class Source>
-#if !defined(BOOST_NO_DECLTYPE)
- decltype((declval<Target>() = declval<Source>(), true_type()))
-#else
- BOOST_TYPEOF_TPL((declval<Target>() = declval<Source>(), true_type()))
-#endif
- test(int);
-
- template <class, class>
- static false_type test(...);
-
- template<class T, class U>
- struct impl {
-#if !defined(BOOST_NO_DECLTYPE)
- typedef decltype(test<T, U>(0)) type;
-#else
- typedef BOOST_TYPEOF_TPL((test<T, U>(0))) type;
-#endif
- };
-#endif //0
-
+ }
}
}
- BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_assignable,To,From,(::boost::detail::is_assignable::impl<To,From>::type::value))
-#else
+ BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_assignable,To,From,(::boost::type_traits::detail::is_assignable::imp<To,From>::type::value))
+#else // BOOST_IS_ASSIGNABLE
BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_assignable,To,From,BOOST_IS_ASSIGNABLE(To,From))
-#endif
+#endif // BOOST_IS_ASSIGNABLE
}
#include <boost/type_traits/detail/bool_trait_undef.hpp>
-#else
-#include <boost/type_traits/integral_constant.hpp>
-namespace boost {
- /**
- * States if the @c Target is assignable from the @c Source.
- *
- * Condition: @c true_type if <c>declval<Target>() = declval<Source>()</c> is well-formed when treated as an
- * unevaluated operand. Access checking is performed as if in a context unrelated to T and U.
- *
- * @Requires @c Target and @c Source shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
- */
-
- template < class Target, class Source>
- struct is_assignable : false_type
- {};
-
- // these specialization are needed because the compiler doesn't support SFINAE on expression
+#endif // doc
- template <> struct is_assignable< bool&, bool const& > : true_type {};
-
- template <> struct is_assignable< int&, int > : true_type {};
- template <> struct is_assignable< int&, int& > : true_type {};
- template <> struct is_assignable< int&, int const& > : true_type {};
- template <> struct is_assignable< int&, double > : true_type {};
- template <> struct is_assignable< int&, short const& > : true_type {};
- template <> struct is_assignable< short&, int const& > : true_type {};
- template <> struct is_assignable< float, int > : true_type {};
- template <> struct is_assignable< int, float > : true_type {};
-
- template <> struct is_assignable< char, char > : true_type {};
- template <> struct is_assignable< char, unsigned char > : true_type {};
- template <> struct is_assignable< char, short > : true_type {};
- template <> struct is_assignable< char, unsigned short > : true_type {};
- template <> struct is_assignable< char, int > : true_type {};
- template <> struct is_assignable< char, unsigned int > : true_type {};
- template <> struct is_assignable< char, long > : true_type {};
- template <> struct is_assignable< char, unsigned long > : true_type {};
-
- template <> struct is_assignable< char, char const& > : true_type {};
- template <> struct is_assignable< char, short const& > : true_type {};
- template <> struct is_assignable< char, int const& > : true_type {};
- template <> struct is_assignable< char, long const& > : true_type {};
- template <> struct is_assignable< char, unsigned char const& > : true_type {};
- template <> struct is_assignable< char, unsigned short const& > : true_type {};
- template <> struct is_assignable< char, unsigned int const& > : true_type {};
- template <> struct is_assignable< char, unsigned long const& > : true_type {};
-
- template <> struct is_assignable< short, char > : true_type {};
- template <> struct is_assignable< short, unsigned char > : true_type {};
- template <> struct is_assignable< short, short > : true_type {};
- template <> struct is_assignable< short, unsigned short > : true_type {};
- template <> struct is_assignable< short, int > : true_type {};
- template <> struct is_assignable< short, unsigned int > : true_type {};
- template <> struct is_assignable< short, long > : true_type {};
- template <> struct is_assignable< short, unsigned long > : true_type {};
-
- template <> struct is_assignable< short, char const& > : true_type {};
- template <> struct is_assignable< short, short const& > : true_type {};
- template <> struct is_assignable< short, int const& > : true_type {};
- template <> struct is_assignable< short, long const& > : true_type {};
- template <> struct is_assignable< short, unsigned char const& > : true_type {};
- template <> struct is_assignable< short, unsigned short const& > : true_type {};
- template <> struct is_assignable< short, unsigned int const& > : true_type {};
- template <> struct is_assignable< short, unsigned long const& > : true_type {};
-
- template <> struct is_assignable< int, char > : true_type {};
- template <> struct is_assignable< int, unsigned char > : true_type {};
- template <> struct is_assignable< int, short > : true_type {};
- template <> struct is_assignable< int, unsigned short > : true_type {};
- template <> struct is_assignable< int, int > : true_type {};
- template <> struct is_assignable< int, unsigned int > : true_type {};
- template <> struct is_assignable< int, long > : true_type {};
- template <> struct is_assignable< int, unsigned long > : true_type {};
-
- template <> struct is_assignable< int, char const& > : true_type {};
- template <> struct is_assignable< int, short const& > : true_type {};
- template <> struct is_assignable< int, int const& > : true_type {};
- template <> struct is_assignable< int, long const& > : true_type {};
- template <> struct is_assignable< int, unsigned char const& > : true_type {};
- template <> struct is_assignable< int, unsigned short const& > : true_type {};
- template <> struct is_assignable< int, unsigned int const& > : true_type {};
- template <> struct is_assignable< int, unsigned long const& > : true_type {};
-
- template <> struct is_assignable< long, char > : true_type {};
- template <> struct is_assignable< long, unsigned char > : true_type {};
- template <> struct is_assignable< long, short > : true_type {};
- template <> struct is_assignable< long, unsigned short > : true_type {};
- template <> struct is_assignable< long, int > : true_type {};
- template <> struct is_assignable< long, unsigned int > : true_type {};
- template <> struct is_assignable< long, long > : true_type {};
- template <> struct is_assignable< long, unsigned long > : true_type {};
-
- template <> struct is_assignable< long, char const& > : true_type {};
- template <> struct is_assignable< long, short const& > : true_type {};
- template <> struct is_assignable< long, int const& > : true_type {};
- template <> struct is_assignable< long, long const& > : true_type {};
- template <> struct is_assignable< long, unsigned char const& > : true_type {};
- template <> struct is_assignable< long, unsigned short const& > : true_type {};
- template <> struct is_assignable< long, unsigned int const& > : true_type {};
- template <> struct is_assignable< long, unsigned long const& > : true_type {};
-
-}
-
-#endif
-
-#endif
-
-#endif
+#endif // header
Modified: sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -31,7 +31,7 @@
*
* @Requires @c T and all types in the parameter pack @c Args must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
*/
- template < class T, class... Args>
+ template < typename T, typename... Args>
struct is_constructible
{};
@@ -46,6 +46,10 @@
#else
#include <boost/config.hpp>
+#include <boost/conversion/type_traits/detail/nat.hpp>
+#include <boost/conversion/type_traits/detail/any.hpp>
+#include <boost/conversion/type_traits/detail/yes_no_types.hpp>
+#include <boost/conversion/type_traits/detail/dummy_size.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
@@ -106,180 +110,164 @@
#define BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE
#endif
-namespace boost {
- namespace type_traits_detail_is_constructible {
- //! type used instead of ... to accept any type
- struct any {
- template <typename T>
- any(T);
- };
- //! not a type. used as default of variadic templates
- struct nat {};
-
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
- }
-}
#ifndef BOOST_NO_VARIADIC_TEMPLATES
namespace boost {
- namespace type_traits_detail_is_constructible {
+ namespace type_traits {
+ namespace detail {
+ namespace is_constructible {
-
- // template <class T, class... Args> struct is_constructible;
-
- // main is_constructible test
+ // main is_constructible test
#if defined BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_DECLTYPE
- #ifndef BOOST_NO_RVALUE_REFERENCES
- template <class T, class ...Args>
- //decltype(move(T(declval<Args>()...)), true_type())
- decltype(T(declval<Args>()...), true_type())
- test(T&&, Args&& ...);
- template <class ...Args>
- false_type
- test(any, Args&& ...);
- #else
- template <class T, class ...Args>
- decltype(T(declval<Args>()...), true_type())
- test(T&, Args& ...);
- template <class ...Args>
- false_type
- test(any, Args& ...);
- #endif
-
- template <bool, class T, class... Args>
- struct imp // false, T is not a scalar
- : public common_type
- <
- decltype(test(declval<T>(), declval<Args>()...))
- >::type
+ #ifndef BOOST_NO_RVALUE_REFERENCES
+ template <typename T, typename ...Args>
+ //decltype(move(T(declval<Args>()...)), true_type())
+ decltype(T(declval<Args>()...), true_type())
+ test(T&&, Args&& ...);
+ template <typename ...Args>
+ false_type
+ test(any, Args&& ...);
+ #else
+ template <typename T, typename ...Args>
+ decltype(T(declval<Args>()...), true_type())
+ test(T&, Args& ...);
+ template <typename ...Args>
+ false_type
+ test(any, Args& ...);
+ #endif
+
+ template <bool, typename T, typename... Args>
+ struct imp // false, T is not a scalar
+ : public common_type
+ <
+ decltype(test(declval<T>(), declval<Args>()...))
+ >::type
{};
#elif defined BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_SIZEOF
- template <bool, class T, class... Args>
- struct imp // false, T is not a scalar
- {
- template<class X>
- static type_traits_detail_is_constructible::yes_type
- test(type_traits_detail_is_constructible::dummy<sizeof(X(declval<Args>()...))>*);
-
- template<class X>
- static type_traits_detail_is_constructible::no_type
- test(...);
-
- static const bool value =
- sizeof(test<T>(0)) == sizeof(type_traits_detail_is_constructible::yes_type);
- typedef boost::integral_constant<bool,value> type;
- };
+ template <bool, typename T, typename... Args>
+ struct imp // false, T is not a scalar
+ {
+ template<typename X>
+ static yes_type
+ test(dummy_size<sizeof(X(declval<Args>()...))>*);
+
+ template<typename X>
+ static no_type
+ test(...);
+
+ static const bool value =
+ sizeof(test<T>(0)) == sizeof(yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
#else
- template <bool, class T, class... Args>
- struct imp // false, T is not a scalar
- : public false_type
- {};
+ template <bool, typename T, typename... Args>
+ struct imp // false, T is not a scalar
+ : public false_type
+ {};
#endif
- // function types are not constructible
+ // function types are not constructible
- template <class R, class... A1, class... A2>
- struct imp<false, R(A1...), A2...>
- : public false_type
- {};
+ template <typename R, typename... A1, typename... A2>
+ struct imp<false, R(A1...), A2...>
+ : public false_type
+ {};
- // handle scalars and reference types
+ // handle scalars and reference types
- // Scalars are default constructible, references are not
+ // Scalars are default constructible, references are not
- template <class T>
- struct imp<true, T>
- : public is_scalar<T>
- {};
+ template <typename T>
+ struct imp<true, T>
+ : public is_scalar<T>
+ {};
- // Scalars and references are constructible from one arg if that arg is
- // implicitly convertible to the scalar or reference.
+ // Scalars and references are constructible from one arg if that arg is
+ // implicitly convertible to the scalar or reference.
- template <class T, class A0>
- struct imp<true, T, A0> : is_convertible<A0,T>
- {};
+ template <typename T, typename A0>
+ struct imp<true, T, A0> : is_convertible<A0,T>
+ {};
- // Scalars and references are not constructible from multiple args.
+ // Scalars and references are not constructible from multiple args.
- template <class T, class A0, class ...Args>
- struct imp<true, T, A0, Args...>
- : public false_type
- {};
+ template <typename T, typename A0, typename ...Args>
+ struct imp<true, T, A0, Args...>
+ : public false_type
+ {};
- // Treat scalars and reference types separately
+ // Treat scalars and reference types separately
- template <bool, class T, class... Args>
- struct void_check
- : public imp<is_scalar<T>::value || is_reference<T>::value,
- T, Args...>
- {};
+ template <bool, typename T, typename... Args>
+ struct void_check
+ : public imp<is_scalar<T>::value || is_reference<T>::value,
+ T, Args...>
+ {};
- // If any of T or Args is void, is_constructible should be false
+ // If any of T or Args is void, is_constructible should be false
- template <class T, class... Args>
- struct void_check<true, T, Args...>
- : public false_type
- {};
+ template <typename T, typename... Args>
+ struct void_check<true, T, Args...>
+ : public false_type
+ {};
- template <class ...Args> struct contains_void;
+ template <typename ...Args> struct contains_void;
- template <> struct contains_void<> : false_type {};
+ template <> struct contains_void<> : false_type {};
- template <class A0, class ...Args>
- struct contains_void<A0, Args...>
- {
- static const bool value = is_void<A0>::value ||
- contains_void<Args...>::value;
- };
+ template <typename A0, typename ...Args>
+ struct contains_void<A0, Args...>
+ {
+ static const bool value = is_void<A0>::value ||
+ contains_void<Args...>::value;
+ };
- }
+ } // is_constructible
+ } // detail
+ } // type_traits
// is_constructible entry point
- template <class T, class... Args>
+ template <typename T, typename... Args>
struct is_constructible
- : public type_traits_detail_is_constructible::void_check<
- type_traits_detail_is_constructible::contains_void<T, Args...>::value
+ : public type_traits::detail::is_constructible::void_check<
+ type_traits::detail::is_constructible::contains_void<T, Args...>::value
|| is_abstract<T>::value,
T, Args...>
{};
- namespace type_traits_detail_is_constructible {
-
+ namespace type_traits {
+ namespace detail {
+ namespace is_constructible {
// Array types are default constructible if their element type
// is default constructible
- template <class A, size_t N>
+ template <typename A, size_t N>
struct imp<false, A[N]>
- : public is_constructible<typename remove_all_extents<A>::type>
+ : public ::boost::is_constructible<typename remove_all_extents<A>::type>
{};
// Otherwise array types are not constructible by this syntax
- template <class A, size_t N, class ...Args>
+ template <typename A, size_t N, typename ...Args>
struct imp<false, A[N], Args...>
: public false_type
{};
// Incomplete array types are not constructible
- template <class A, class ...Args>
+ template <typename A, typename ...Args>
struct imp<false, A[], Args...>
: public false_type
{};
- }
-}
+ } // is_constructible
+ } // detail
+ } // type_traits
+} // boost
#else // BOOST_NO_VARIADIC_TEMPLATES
/////////////////
@@ -290,14 +278,16 @@
namespace boost {
- template <class T, BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX), class A, = type_traits_detail_is_constructible::nat BOOST_PP_INTERCEPT)> \
+ template <typename T, BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX), typename A, = type_traits::detail::nat BOOST_PP_INTERCEPT)> \
struct is_constructible;
- namespace type_traits_detail_is_constructible {
+ namespace type_traits {
+ namespace detail {
+ namespace is_constructible {
#if defined BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_DECLTYPE
// specific test functions for 0 args which are not templates
- template <class T>
+ template <typename T>
decltype((T(), true_type()))
test0(T&);
false_type
@@ -307,7 +297,7 @@
#define M1(z,n,t) declval<A##n>()
#define M0(z,n,t) \
- template <class T, BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <typename T, BOOST_PP_ENUM_PARAMS(n, typename A)> \
decltype((T(BOOST_PP_ENUM(n, M1, ~)), true_type())) \
test##n(T&, BOOST_PP_ENUM_PARAMS(n, A));
@@ -317,7 +307,7 @@
// specific negative test functions for #Args>0
#define M0(z,n,t) \
- template <BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <BOOST_PP_ENUM_PARAMS(n, typename A)> \
false_type \
test##n(any, BOOST_PP_ENUM_PARAMS(n, A));
@@ -330,7 +320,7 @@
#define M1(z,n,t) declval<A##n>()
#define M0(z,n,t) \
- template <bool, class T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <bool, typename T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct imp##n : public common_type \
< \
decltype(test##n(declval<T&>() BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, M1, ~))) \
@@ -350,19 +340,19 @@
#define M1(z,n,t) declval<A##n>()
#define M0(z,n,t) \
-template<bool, class T, BOOST_PP_ENUM_PARAMS(n, class A)> \
+template<bool, typename T, BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct imp##n \
{ \
- template<class X> \
- static type_traits_detail_is_constructible::yes_type \
- test(type_traits_detail_is_constructible::dummy<sizeof(X(BOOST_PP_ENUM(n, M1, ~)))>*); \
+ template<typename X> \
+ static yes_type \
+ test(dummy_size<sizeof(X(BOOST_PP_ENUM(n, M1, ~)))>*); \
\
- template<class X> \
- static type_traits_detail_is_constructible::no_type \
+ template<typename X> \
+ static no_type \
test(...); \
\
static const bool value = \
- sizeof(test<T>(0)) == sizeof(type_traits_detail_is_constructible::yes_type); \
+ sizeof(test<T>(0)) == sizeof(yes_type); \
typedef boost::integral_constant<bool,value> type; \
};
@@ -375,22 +365,22 @@
// specialization for void, abstract, function or any of the parameters is void, scalar or reference
// and no arg:
// depend is whether X() seen as a constructor call is well formed
- template<bool, class T>
+ template<bool, typename T>
struct imp0
{
- template<class X>
- static type_traits_detail_is_constructible::yes_type
- test(type_traits_detail_is_constructible::dummy<sizeof(X(),int())>*);
+ template<typename X>
+ static yes_type
+ test(dummy_size<sizeof(X(),int())>*);
- template<class X>
- static type_traits_detail_is_constructible::no_type
+ template<typename X>
+ static no_type
test(...);
- static const bool value = sizeof(test<T>(0)) == sizeof(type_traits_detail_is_constructible::yes_type);
+ static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
typedef boost::integral_constant<bool,value> type;
};
#else
- template<bool, class T>
+ template<bool, typename T>
struct imp0 : public false_type {};
#endif
@@ -403,7 +393,7 @@
// always false. The user of the library needs to specialize this trait for its owns types.
#define M0(z,n,t) \
-template<bool, class T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)> \
+template<bool, typename T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct imp##n \
: boost::false_type \
{ \
@@ -415,20 +405,20 @@
#endif
// specialization for scalar or reference with 1 arg: depend is the arg is scalar
- template <class T>
+ template <typename T>
struct imp0<true, T>
: public is_scalar<T>
{};
// specialization for scalar or reference with 1 arg: depend is the arg is convertible to the type
- template <class T, class A1>
+ template <typename T, typename A1>
struct imp1<true, T, A1>
: public is_convertible<A1, T>
{};
// specialization for scalar or reference with multiple args: always false
#define M0(z,n,t) \
-template <class T, BOOST_PP_ENUM_PARAMS(n, class A)> \
+template <typename T, BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct imp##n<true, T, BOOST_PP_ENUM_PARAMS(n, A) > \
: public false_type \
{};
@@ -440,7 +430,7 @@
// depends on whether the type is scalar or reference
#define M0(z,n,t) \
- template <bool, class T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <bool, typename T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct void_check##n \
: public imp##n<is_scalar<T>::value || is_reference<T>::value, \
T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, A)> \
@@ -451,7 +441,7 @@
// specialization for void, abstract, function or any of the parameters is void: always false
#define M0(z,n,t) \
- template <class T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <typename T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct void_check##n<true, T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, A)> \
: public false_type \
{};
@@ -463,7 +453,7 @@
// specialization for unbounded arrays: always false
#define M0(z,n,t) \
- template <class A BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <typename A BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct imp##n<false, A[] BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, A)> \
: public false_type \
{};
@@ -471,16 +461,18 @@
BOOST_PP_REPEAT(BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX, M0, ~)
#undef M0
- }
+ } // is_constructible
+ } // detail
+ } // type_traits
// defines is_constructible, depending on whether T is void, abstract, function or any of the parameters is void
#define M1(z,n,t) || is_void<A##n>::value
#define M0(z,n,t) \
- template <class T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <typename T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct is_constructible<T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, A)> \
- : public type_traits_detail_is_constructible::void_check##n<is_void<T>::value \
+ : public type_traits::detail::is_constructible::void_check##n<is_void<T>::value \
|| is_abstract<T>::value || is_function<T>::value \
BOOST_PP_REPEAT(n, M1, ~), \
T BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, A)> \
@@ -489,16 +481,18 @@
BOOST_PP_REPEAT(BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX, M0, ~)
#undef M0
- namespace type_traits_detail_is_constructible {
- // specialization for bounded arrays without arguments: depends on the type
- template <class A, std::size_t N>
+ namespace type_traits {
+ namespace detail {
+ namespace is_constructible {
+// specialization for bounded arrays without arguments: depends on the type
+ template <typename A, std::size_t N>
struct imp0<false, A[N]>
: public boost::is_constructible<typename remove_all_extents<A>::type>
{};
// specialization for bounded arrays with arguments: always false
#define M0(z,n,t) \
- template <class A, std::size_t N, BOOST_PP_ENUM_PARAMS(n, class A)> \
+ template <typename A, std::size_t N, BOOST_PP_ENUM_PARAMS(n, typename A)> \
struct imp##n<false, A[N], BOOST_PP_ENUM_PARAMS(n, A)> \
: public false_type \
{};
@@ -507,8 +501,10 @@
#undef M0
- }
-}
+ } // is_constructible
+ } // detail
+ } // type_traits
+} // boost
#endif // variadic
#endif // doc
Modified: sandbox/conversion/boost/conversion/type_traits/is_convertible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_convertible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_convertible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -33,39 +33,39 @@
template < >
struct is_convertible< void, const void> : true_type {};
- template < class Target, class Source, std::size_t N>
+ template < typename Target, typename Source, std::size_t N>
struct is_convertible< Target[N], Source[N] >: false_type {};
- template < class Target, class Source, std::size_t N>
+ template < typename Target, typename Source, std::size_t N>
struct is_convertible< const Target[N], const Source[N] >: false_type {};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_convertible< std::pair<A1,A2>, std::pair<B1,B2> >
: integral_constant<bool, is_convertible<A1,B1>::value && is_convertible<A2,B2>::value >
{};
#if 0
- template <class T1, class T2, std::size_t N>
+ template <typename T1, typename T2, std::size_t N>
struct is_convertible< boost::array<T1,N>, boost::array<T2,N> >
: integral_constant<bool, is_convertible<T1,T2>::value >
{};
#endif
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct is_convertible< std::complex<Target>, std::complex<Source> >
: integral_constant<bool, is_convertible<Target,Source>::value >
{};
- template < class T1, class A1, class T2, class A2>
+ template < typename T1, typename A1, typename T2, typename A2>
struct is_convertible< std::vector<T1,A1>, std::vector<T2,A2> >
: integral_constant<bool, is_convertible<T1,T2>::value >
{};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_convertible< fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >
: integral_constant<bool, is_convertible<A1,B1>::value && is_convertible<A2,B2>::value >
{};
- template <class A1, class A2, class A3, class B1, class B2, class B3>
+ template <typename A1, typename A2, typename A3, typename B1, typename B2, typename B3>
struct is_convertible< fusion::tuple<A1,A2,A3>, fusion::tuple<B1,B2,B3> >
: integral_constant<bool, is_convertible<A1,B1>::value && is_convertible<A2,B2>::value&& is_convertible<A3,B3>::value >
{};
Modified: sandbox/conversion/boost/conversion/type_traits/is_copy_assignable.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_copy_assignable.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_copy_assignable.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -29,7 +29,7 @@
*
* @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
*/
- template <class T>
+ template <typename T>
struct is_copy_assignable : is_assignable<
T&,
T const&
Modified: sandbox/conversion/boost/conversion/type_traits/is_copy_constructible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_copy_constructible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_copy_constructible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -30,7 +30,7 @@
*
* @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
*/
- template <class T>
+ template <typename T>
struct is_copy_constructible : is_constructible<
T,
T const&
Modified: sandbox/conversion/boost/conversion/type_traits/is_default_constructible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_default_constructible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_default_constructible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -30,7 +30,7 @@
*
* @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
*/
- template <class T>
+ template <typename T>
struct is_default_constructible : is_constructible<
T
> {};
Modified: sandbox/conversion/boost/conversion/type_traits/is_destructible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_destructible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_destructible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -23,7 +23,7 @@
* Condition: @c true_type if and only if given:
*
* @code
- * template <class U>
+ * template <typename U>
* struct test {
* U u;
* };
@@ -39,7 +39,7 @@
*
* @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
*/
- template <class T>
+ template <typename T>
struct is_destructible
{};
@@ -51,6 +51,9 @@
#include <boost/config.hpp>
+#include <boost/conversion/type_traits/detail/any.hpp>
+#include <boost/conversion/type_traits/detail/yes_no_types.hpp>
+#include <boost/conversion/type_traits/detail/dummy_size.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/common_type.hpp>
#include <boost/type_traits/is_scalar.hpp>
@@ -104,30 +107,19 @@
#endif
namespace boost {
- namespace type_traits_detail_is_destructible {
- struct any {
- template <typename T>
- any(T);
- };
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
-
- template <class U>
+ namespace type_traits {
+ namespace detail {
+ namespace is_destructible {
+ template <typename U>
struct test
{
U u;
};
- template <class T, bool False = is_void<T>::value || is_abstract<T>::value, bool True = is_scalar<T>::value >
+ template <typename T, bool False = is_void<T>::value || is_abstract<T>::value, bool True = is_scalar<T>::value >
struct imp;
#if defined BOOST_CONVERSION_IS_DESTRUCTIBLE_USES_DECLTYPE
- template <class T>
+ template <typename T>
decltype((declval<test<T> >().~test<T>(), true_type()))
#if defined BOOST_CONVERSION_TT_IS_DESTRUCTIBLE_USES_RVALUE
selector(T&&);
@@ -138,44 +130,46 @@
false_type
selector(any);
- template <class T>
+ template <typename T>
struct imp<T,false,false>
: public common_type<decltype(selector(declval<T>()))>::type {};
#elif defined BOOST_CONVERSION_IS_DESTRUCTIBLE_USES_SIZEOF
- template <class T>
+ template <typename T>
struct imp<T,false,false>
{
- template<class X>
- static type_traits_detail_is_destructible::yes_type
- selector(type_traits_detail_is_destructible::dummy<sizeof(declval<test<T> >().~test<T>(),int())>*);
+ template<typename X>
+ static yes_type
+ selector(dummy_size<sizeof(declval<test<T> >().~test<T>(),int())>*);
- template<class X>
- static type_traits_detail_is_destructible::no_type
+ template<typename X>
+ static no_type
selector(...);
static const bool value =
- sizeof(selector<T>(0)) == sizeof(type_traits_detail_is_destructible::yes_type);
+ sizeof(selector<T>(0)) == sizeof(yes_type);
typedef boost::integral_constant<bool,value> type;
};
#else
- template <class T>
+ template <typename T>
struct imp<T,false,false>
: public false_type {};
#endif
- template <class T, bool IsScalar>
+ template <typename T, bool IsScalar>
struct imp<T, true, IsScalar>
: public false_type {};
- template <class T>
+ template <typename T>
struct imp<T, false, true>
: public true_type {};
+ }
+ }
}
- template <class T>
+ template <typename T>
struct is_destructible
- : public type_traits_detail_is_destructible::imp<T> {};
+ : public type_traits::detail::is_destructible::imp<T> {};
/**
* @c is_destructible specialization for reference types.
Modified: sandbox/conversion/boost/conversion/type_traits/is_explicitly_convertible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_explicitly_convertible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_explicitly_convertible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -37,7 +37,7 @@
* was accepted. The library uses by default the static_cast version. Users can force the is_constructible version by defining
* @c BOOST_CONVERSION_TT_IS_EXPLICITLY_CONVERTIBLE_USES_IS_CONSTRUCTIBLE.
*/
- template < class Source, class Target>
+ template < typename Source, typename Target>
struct is_explicitly_convertible
{};
@@ -57,9 +57,9 @@
namespace boost {
- template <class Source, class Target>
+ template <typename Source, typename Target>
struct is_explicitly_convertible : is_constructible<Target, Source> {};
- template <class Target>
+ template <typename Target>
struct is_explicitly_convertible<void,Target> : false_type {};
@@ -68,6 +68,9 @@
#else
#include <boost/config.hpp>
+#include <boost/conversion/type_traits/detail/any.hpp>
+#include <boost/conversion/type_traits/detail/yes_no_types.hpp>
+#include <boost/conversion/type_traits/detail/dummy_size.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/utility/declval.hpp>
#include <cstddef>
@@ -113,41 +116,25 @@
namespace boost {
- namespace type_traits_detail_is_explicitly_convertible {
- //! type used instead of ... to accept any type
- struct any {
- template <typename T>
- any(T);
- };
-
- //! type useful to compare with the sizeof
- typedef char yes_type;
- //! type useful to compare with the sizeof
- struct no_type { char a[2]; };
-
- //! type useful to accept a sizeof as parameter
- template<std::size_t N>
- struct dummy;
- }
-
-
- namespace type_traits_detail_is_explicitly_convertible {
+ namespace type_traits {
+ namespace detail {
+ namespace is_explicitly_convertible {
#if defined BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_DECLTYPE
// specific positive test functions
- template <class S, class T>
+ template <typename S, typename T>
decltype((static_cast<T>(declval<S>()), true_type()))
test(T&, S);
// specific negative test functions
- template <class S>
+ template <typename S>
false_type
test(any, S);
// specialization for NOT void, abstract, function or any of the parameters is void, scalar or reference
// depends on whether static_cast<T>(declval<S>()) is well formed
- template <bool, class S, class T>
+ template <bool, typename S, typename T>
struct imp
: public common_type<decltype(test(declval<T&>(), declval<S>()))>::type
{};
@@ -158,19 +145,19 @@
// specialization for void, abstract, function or any of the parameters is void, scalar or reference
// depends on whether static_cast<T>(declval<Args>() ...) is well formed
-template<bool, class S, class T>
+template<bool, typename S, typename T>
struct imp
{
- template<class X>
- static type_traits_detail_is_explicitly_convertible::yes_type
- test(type_traits_detail_is_explicitly_convertible::dummy<sizeof(static_cast<X>(declval<S>()))>*);
+ template<typename X>
+ static yes_type
+ test(dummy_size<sizeof(static_cast<X>(declval<S>()))>*);
- template<class X>
- static type_traits_detail_is_explicitly_convertible::no_type
+ template<typename X>
+ static no_type
test(...);
static const bool value =
- sizeof(test<T>(0)) == sizeof(type_traits_detail_is_explicitly_convertible::yes_type);
+ sizeof(test<T>(0)) == sizeof(yes_type);
typedef boost::integral_constant<bool,value> type;
};
@@ -182,7 +169,7 @@
// allows to detect if static_cast<Target>(declval<Source>()) is well formed
// always false. The user of the library needs to specialize this trait for its owns types.
-template<bool, class S, class T>
+template<bool, typename S, typename T>
struct imp
: boost::false_type
{
@@ -193,7 +180,7 @@
// specialization for scalar or reference: depend on the source is convertible to the target
- template <class S, class T>
+ template <typename S, typename T>
struct imp<true, S, T>
: public integral_constant<bool,is_convertible<S,T>::value || imp<false,S,T>::value >
{};
@@ -201,7 +188,7 @@
// specialization for NOT void, abstract, function or any of the parameters is void:
// depends on whether the type is scalar or reference
- template <bool, class S, class T>
+ template <bool, typename S, typename T>
struct void_check
: public imp<is_scalar<T>::value || is_reference<T>::value,
S, T>
@@ -209,7 +196,7 @@
// specialization for void, abstract, function or any of the parameters is void: always false
- template <class S, class T>
+ template <typename S, typename T>
struct void_check<true, S, T>
: public false_type
{};
@@ -217,18 +204,20 @@
// specialization for unbounded arrays: always false
- template <class S, class A>
+ template <typename S, typename A>
struct imp<false, S, A[]>
: public false_type
{};
+ }
+ }
}
// defines is_explicitly_convertible, depending on whether T is void, abstract, function or any of the parameters is void
- template <class S, class T>
+ template <typename S, class T>
struct is_explicitly_convertible
- : public type_traits_detail_is_explicitly_convertible::void_check<is_void<T>::value
+ : public type_traits::detail::is_explicitly_convertible::void_check<is_void<T>::value
|| is_abstract<T>::value || is_function<T>::value
|| is_void<S>::value,
S, T>
Modified: sandbox/conversion/boost/conversion/type_traits/is_move_assignable.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_move_assignable.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_move_assignable.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -15,6 +15,9 @@
#ifndef BOOST_CONVERSION_TT_IS_MOVE_ASSIGNABLE_HPP
#define BOOST_CONVERSION_TT_IS_MOVE_ASSIGNABLE_HPP
+#include <boost/conversion/type_traits/detail/any.hpp>
+#include <boost/conversion/type_traits/detail/yes_no_types.hpp>
+#include <boost/conversion/type_traits/detail/dummy_size.hpp>
#include <boost/conversion/type_traits/is_assignable.hpp>
#include <boost/conversion/type_traits/is_copy_assignable.hpp>
@@ -46,7 +49,7 @@
*
* @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
*/
- template <class T>
+ template <typename T>
struct is_move_assignable :
#if defined BOOST_CONVERSION_TT_IS_MOVE_ASSIGNABLE_USES_RVALUE
is_assignable<T&, T&&>
Modified: sandbox/conversion/boost/conversion/type_traits/is_move_constructible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_move_constructible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_move_constructible.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -16,6 +16,9 @@
#ifndef BOOST_CONVERSION_TT_IS_MOVE_CONSTRUCTIBLE_HPP
#define BOOST_CONVERSION_TT_IS_MOVE_CONSTRUCTIBLE_HPP
+#include <boost/conversion/type_traits/detail/any.hpp>
+#include <boost/conversion/type_traits/detail/yes_no_types.hpp>
+#include <boost/conversion/type_traits/detail/dummy_size.hpp>
#include <boost/conversion/type_traits/is_constructible.hpp>
#include <boost/conversion/type_traits/is_copy_constructible.hpp>
#include <boost/type_traits/remove_reference.hpp>
@@ -46,7 +49,7 @@
*
* @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
*/
- template <class T>
+ template <typename T>
struct is_move_constructible :
#if defined BOOST_CONVERSION_TT_IS_MOVE_CONSTRUCTIBLE_USES_RVALUE
is_constructible<T, typename add_rvalue_reference<T>::type>
Modified: sandbox/conversion/boost/conversion/type_traits/std/complex.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/std/complex.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/std/complex.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -24,27 +24,27 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class T >
+ template < typename T >
struct is_constructible< std::complex<T> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class T >
+ template < typename T >
struct is_constructible< std::complex<T>, std::complex<T> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class T >
+ template < typename T >
struct is_assignable< std::complex<T>, std::complex<T> > : true_type {};
- template < class T >
+ template < typename T >
struct is_assignable< std::complex<T>&, std::complex<T> const& > : true_type {};
#endif
// These specializations are needed because the std library implementation is not using SFINAE
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct is_constructible< std::complex<Target>, std::complex<Source> >
: integral_constant<bool, is_constructible<Target,Source>::value >
{};
- template < class Target, class Source>
+ template < typename Target, typename Source>
struct is_assignable< std::complex<Target>, std::complex<Source> >
: integral_constant<bool, is_assignable<Target,Source>::value >
{};
Modified: sandbox/conversion/boost/conversion/type_traits/std/utility.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/std/utility.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/std/utility.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -26,34 +26,34 @@
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
//! Specialization for std::pair<T,U> default constructor
- template < class T, class U>
+ template < typename T, typename U>
struct is_constructible< std::pair<T,U> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
//! Specialization for std::pair<T,U> default copy constructor
- template < class T, class U>
+ template < typename T, typename U>
struct is_constructible< std::pair<T,U>, std::pair<T,U> const& > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
//! Specialization for std::pair<T,U> assignment operator
- template < class T, class U>
+ template < typename T, typename U>
struct is_assignable< std::pair<T,U>, std::pair<T,U> > : true_type {};
//! Specialization for std::pair<T,U> assignment operator
- template < class T, class U>
+ template < typename T, typename U>
struct is_assignable< std::pair<T,U>&, std::pair<T,U> const& > : true_type {};
#endif
// these specializations are needed because the libraries define the assignment operator without using SFINAE
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_constructible< std::pair<A1,A2>, std::pair<B1,B2> >
: integral_constant<bool, is_constructible<A1,B1>::value && is_constructible<A2,B2>::value >
{};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_explicitly_convertible< std::pair<A1,A2>, std::pair<B1,B2> >
: integral_constant<bool, is_explicitly_convertible<A1,B1>::value && is_explicitly_convertible<A2,B2>::value >
{};
- template <class A1, class A2, class B1, class B2>
+ template <typename A1, typename A2, typename B1, typename B2>
struct is_assignable< std::pair<A1,A2>, std::pair<B1,B2> >
: integral_constant<bool, is_assignable<A1,B1>::value && is_assignable<A2,B2>::value >
{};
Modified: sandbox/conversion/boost/conversion/type_traits/std/vector.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/std/vector.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/std/vector.hpp 2011-08-13 05:31:11 EDT (Sat, 13 Aug 2011)
@@ -23,28 +23,28 @@
namespace boost {
#if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE)
- template < class T, class A>
+ template < typename T, typename A>
struct is_constructible< std::vector<T,A> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE)
- template < class T, class A>
+ template < typename T, typename A>
struct is_constructible< std::vector<T,A>, std::vector<T,A> > : true_type {};
#endif
#if defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
- template < class T, class A>
+ template < typename T, typename A>
struct is_assignable< std::vector<T,A>&, std::vector<T,A> const& > : true_type {};
- template < class T, class A>
+ template < typename T, typename A>
struct is_assignable< std::vector<T,A>, std::vector<T,A> > : true_type {};
#endif
// these specializations are needed because the libraries define the assignment operator without using SFINAE
- template < class T1, class A1, class T2, class A2>
+ template < typename T1, typename A1, typename T2, typename A2>
struct is_constructible< std::vector<T1,A1>, std::vector<T2,A2> >
: integral_constant<bool, is_constructible<T1,T2>::value >
{};
- template < class T1, class A1, class T2, class A2>
+ template < typename T1, typename A1, typename T2, typename A2>
struct is_assignable< std::vector<T1,A1>, std::vector<T2,A2> >
: integral_constant<bool, is_assignable<T1,T2>::value >
{};