Subject: [Boost-commit] svn:boost r73867 - in sandbox/conversion/boost/conversion: . boost detail
From: vicente.botet_at_[hidden]
Date: 2011-08-17 18:21:26
Author: viboes
Date: 2011-08-17 18:21:24 EDT (Wed, 17 Aug 2011)
New Revision: 73867
URL: http://svn.boost.org/trac/boost/changeset/73867
Log:
conversion: change _explicit_ by _explictly_
Added:
sandbox/conversion/boost/conversion/detail/is_extrinsically_explicitly_convertible_or_fallback_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/detail/is_extrinsically_explicitly_convertible_tagged.hpp (contents, props changed)
sandbox/conversion/boost/conversion/is_extrinsically_explicitly_convertible.hpp (contents, props changed)
Text files modified:
sandbox/conversion/boost/conversion/assign_to.hpp | 4 ++--
sandbox/conversion/boost/conversion/boost/optional.hpp | 2 +-
sandbox/conversion/boost/conversion/convert_to.hpp | 4 ++--
sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp | 12 ++++++------
sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp | 14 +++++++-------
sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp | 14 +++++++-------
sandbox/conversion/boost/conversion/explicit_convert_to.hpp | 6 +++---
sandbox/conversion/boost/conversion/include.hpp | 2 +-
sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible.hpp | 18 +++++++++---------
sandbox/conversion/boost/conversion/try_assign_to.hpp | 4 ++--
sandbox/conversion/boost/conversion/try_convert_to.hpp | 8 ++++----
11 files changed, 44 insertions(+), 44 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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -42,7 +42,7 @@
#include <boost/conversion/type_traits/is_copy_assignable.hpp>
#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/conversion/is_extrinsically_explicitly_convertible.hpp>
#include <boost/type_traits/add_reference.hpp>
namespace boost {
@@ -92,7 +92,7 @@
#else
, typename enable_if_c<
is_copy_assignable<Target>::value
- && is_extrinsically_explicit_convertible<Source,Target>::value
+ && is_extrinsically_explicitly_convertible<Source,Target>::value
&& ! is_assignable<Target,Source>::value
>::type
#endif
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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -109,7 +109,7 @@
)
#else
, typename enable_if_c<
- is_extrinsically_explicit_convertible<Source,Target>::value
+ is_extrinsically_explicitly_convertible<Source,Target>::value
&& ! detail::is_optional<Source>::value
>::type
#endif
Modified: sandbox/conversion/boost/conversion/convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/convert_to.hpp (original)
+++ sandbox/conversion/boost/conversion/convert_to.hpp 2011-08-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -20,7 +20,7 @@
#include <boost/conversion/explicit_convert_to.hpp>
-#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
+#include <boost/conversion/is_extrinsically_explicitly_convertible.hpp>
namespace boost {
@@ -45,7 +45,7 @@
#if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
//typename disable_if<typename conversion::enable_functor<Source>::type, Target>::type
typename enable_if_c<
- conversion::is_extrinsically_explicit_convertible<Source,Target>::value,
+ conversion::is_extrinsically_explicitly_convertible<Source,Target>::value,
Target
>::type
#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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -41,7 +41,7 @@
#include <boost/conversion/config.hpp>
#include <boost/conversion/convert_to.hpp>
-#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
+#include <boost/conversion/is_extrinsically_explicitly_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/utility/enable_if.hpp>
@@ -87,8 +87,8 @@
&& ExtrinsicallyExplicitConvertible<Fallback,Target>)
#else
typename enable_if_c<
- is_extrinsically_explicit_convertible<Source,Target>::value
- && is_extrinsically_explicit_convertible<Fallback,Target>::value
+ is_extrinsically_explicitly_convertible<Source,Target>::value
+ && is_extrinsically_explicitly_convertible<Fallback,Target>::value
>::type
#endif
> : true_type
@@ -142,7 +142,7 @@
}
}
-#include <boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp>
+#include <boost/conversion/detail/is_extrinsically_explicitly_convertible_or_fallback_tagged.hpp>
namespace boost {
namespace conversion {
@@ -164,7 +164,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
+ && is_extrinsically_explicitly_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);
@@ -183,7 +183,7 @@
//! @endcode
template <typename Target, typename Source>
typename enable_if_c<
- is_extrinsically_explicit_convertible_or_fallback_tagged<Source,Target,Target>::value
+ is_extrinsically_explicitly_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/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp (original)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_or_fallback_tagged.hpp 2011-08-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -9,7 +9,7 @@
//////////////////////////////////////////////////////////////////////////////
/**
* @file
- * @brief Defines the type trait @c is_extrinsically_explicit_convertible_or_fallback.
+ * @brief Defines the type trait @c is_extrinsically_explicitly_convertible_or_fallback.
*/
#ifndef BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_HPP
@@ -32,9 +32,9 @@
*
*/
template <typename Source, typename Target>
- struct is_extrinsically_explicit_convertible_or_fallback_tagged {};
+ struct is_extrinsically_explicitly_convertible_or_fallback_tagged {};
- //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible_or_fallback type trait for classes.
+ //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicitly_convertible_or_fallback type trait for classes.
#define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED
}
@@ -113,7 +113,7 @@
namespace conversion {
namespace impl_2 {}
namespace detail {
- namespace is_extrinsically_explicit_convertible_or_fallback_tagged {
+ namespace is_extrinsically_explicitly_convertible_or_fallback_tagged {
using namespace boost::conversion::impl_2;
template <typename S, typename T, typename F,
@@ -205,13 +205,13 @@
struct imp<S, T, F, B, true>
: public false_type {};
- } // is_extrinsically_explicit_convertible_or_fallback_tagged
+ } // is_extrinsically_explicitly_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> {};
+ struct is_extrinsically_explicitly_convertible_or_fallback_tagged
+ : public detail::is_extrinsically_explicitly_convertible_or_fallback_tagged::imp<Source, Target, Fallback> {};
} // conversion
} // boost
Modified: sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp (original)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp 2011-08-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -9,7 +9,7 @@
//////////////////////////////////////////////////////////////////////////////
/**
* @file
- * @brief Defines the type trait @c is_extrinsically_explicit_convertible.
+ * @brief Defines the type trait @c is_extrinsically_explicitly_convertible.
*/
#ifndef BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_HPP
@@ -32,9 +32,9 @@
*
*/
template <typename Source, typename Target>
- struct is_extrinsically_explicit_convertible_tagged {};
+ struct is_extrinsically_explicitly_convertible_tagged {};
- //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible type trait for classes.
+ //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicitly_convertible type trait for classes.
#define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED
}
@@ -113,7 +113,7 @@
namespace conversion {
namespace impl_2 {}
namespace detail {
- namespace is_extrinsically_explicit_convertible_tagged {
+ namespace is_extrinsically_explicitly_convertible_tagged {
using namespace boost::conversion::impl_2;
template <typename S, typename T,
@@ -207,13 +207,13 @@
struct imp<S, T, B,true>
: public false_type {};
- } // is_extrinsically_explicit_convertible_tagged
+ } // is_extrinsically_explicitly_convertible_tagged
} // detail
template <typename Source, typename Target>
- struct is_extrinsically_explicit_convertible_tagged
- : public detail::is_extrinsically_explicit_convertible_tagged::imp<Source, Target> {};
+ struct is_extrinsically_explicitly_convertible_tagged
+ : public detail::is_extrinsically_explicitly_convertible_tagged::imp<Source, Target> {};
} // conversion
} // boost
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_explicitly_convertible_or_fallback_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_explicitly_convertible_or_fallback_tagged.hpp 2011-08-17 18:21:24 EDT (Wed, 17 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_explicitly_convertible_or_fallback.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_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_explicitly_convertible_or_fallback_tagged {};
+
+ //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicitly_convertible_or_fallback type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED
+ #endif
+ #elif defined __clang__
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED
+ #endif
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_DECLTYPE
+ #endif
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_DECLTYPE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined __clang__
+#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #else
+ #error
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_OR_FALLBACK_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace impl_2 {}
+ namespace detail {
+ namespace is_extrinsically_explicitly_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_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_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_explicitly_convertible_or_fallback_tagged
+ } // detail
+
+
+ template <typename Source, typename Target, typename Fallback>
+ struct is_extrinsically_explicitly_convertible_or_fallback_tagged
+ : public detail::is_extrinsically_explicitly_convertible_or_fallback_tagged::imp<Source, Target, Fallback> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#endif // header
+
Added: sandbox/conversion/boost/conversion/detail/is_extrinsically_explicitly_convertible_tagged.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/detail/is_extrinsically_explicitly_convertible_tagged.hpp 2011-08-17 18:21:24 EDT (Wed, 17 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_explicitly_convertible.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_HPP
+#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_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_explicitly_convertible_tagged {};
+
+ //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicitly_convertible type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED
+ #endif
+ #elif defined __clang__
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED
+ #endif
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #endif
+ #else
+#error
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_DECLTYPE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #if defined __clang__
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #elif defined __GNUC__
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #else
+ #error
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_SIZEOF
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_TAGGED_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace impl_2 {}
+ namespace detail {
+ namespace is_extrinsically_explicitly_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_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_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_explicitly_convertible_tagged
+ } // detail
+
+
+ template <typename Source, typename Target>
+ struct is_extrinsically_explicitly_convertible_tagged
+ : public detail::is_extrinsically_explicitly_convertible_tagged::imp<Source, Target> {};
+
+} // conversion
+} // boost
+
+#endif // doc
+
+#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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -149,7 +149,7 @@
}
}
-#include <boost/conversion/detail/is_extrinsically_explicit_convertible_tagged.hpp>
+#include <boost/conversion/detail/is_extrinsically_explicitly_convertible_tagged.hpp>
namespace boost {
namespace conversion {
@@ -175,7 +175,7 @@
//! @endcode
template <typename Target, typename Source>
typename enable_if_c<
- is_extrinsically_explicit_convertible_tagged<Source,Target>::value
+ is_extrinsically_explicitly_convertible_tagged<Source,Target>::value
, Target>::type
explicit_convert_to(Source const& from)
{
@@ -190,7 +190,7 @@
//! @tparam Target target type of the conversion.
//! @tparam Source source type of the conversion.
//!
- //! @Requires @c is_extrinsically_explicit_convertible<Source,Target>
+ //! @Requires @c is_extrinsically_explicitly_convertible<Source,Target>
//! @Remarks We can see this specialization as a try_convert_to function.
template < typename Target, typename Source>
struct explicit_converter< optional<Target>, Source,
Modified: sandbox/conversion/boost/conversion/include.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/include.hpp (original)
+++ sandbox/conversion/boost/conversion/include.hpp 2011-08-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -27,6 +27,6 @@
#include <boost/conversion/try_assign_to.hpp>
#include <boost/conversion/is_extrinsically_assignable.hpp>
#include <boost/conversion/is_extrinsically_convertible.hpp>
-#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
+#include <boost/conversion/is_extrinsically_explicitly_convertible.hpp>
#endif
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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -9,7 +9,7 @@
//////////////////////////////////////////////////////////////////////////////
/**
* @file
- * @brief Defines the type trait @c is_extrinsically_explicit_convertible.
+ * @brief Defines the type trait @c is_extrinsically_explicitly_convertible.
*/
#ifndef BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_HPP
@@ -35,9 +35,9 @@
* - Otherwise, the trait is equivalent to @c boost::conversion::explicit_converter<Target,Source>.
*/
template <class Source, class Target>
- struct is_extrinsically_explicit_convertible {};
+ struct is_extrinsically_explicitly_convertible {};
- //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicit_convertible type trait for classes.
+ //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicitly_convertible type trait for classes.
#define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE
}
@@ -107,7 +107,7 @@
namespace boost {
namespace conversion {
namespace detail {
- namespace is_extrinsically_explicit_convertible {
+ namespace is_extrinsically_explicitly_convertible {
template <class S, class T,
bool True =
@@ -170,7 +170,7 @@
#else
template <class S, class T>
struct imp<S,T,false,false>
- : public conversion::is_extrinsically_explicit_convertible_tagged<S,T> {};
+ : public conversion::is_extrinsically_explicitly_convertible_tagged<S,T> {};
#endif
template <class S, class T, std::size_t N>
struct imp<S[N],T[N],false,false>
@@ -210,15 +210,15 @@
template <class S,class T,bool B>
struct imp<S, T, B,true>
: public false_type {};
- } // is_extrinsically_explicit_convertible
+ } // is_extrinsically_explicitly_convertible
} // detail
template <class Source, class Target>
- struct is_extrinsically_explicit_convertible
- : public detail::is_extrinsically_explicit_convertible::imp<Source, Target> {};
+ struct is_extrinsically_explicitly_convertible
+ : public detail::is_extrinsically_explicitly_convertible::imp<Source, Target> {};
template <class T>
- struct is_extrinsically_explicit_convertible<fusion::void_,T> : false_type {};
+ struct is_extrinsically_explicitly_convertible<fusion::void_,T> : false_type {};
}
}
Added: sandbox/conversion/boost/conversion/is_extrinsically_explicitly_convertible.hpp
==============================================================================
--- (empty file)
+++ sandbox/conversion/boost/conversion/is_extrinsically_explicitly_convertible.hpp 2011-08-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -0,0 +1,227 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_explicitly_convertible.
+ */
+
+#ifndef BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_HPP
+#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_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.
+ *
+ * @Remark
+ * - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation.
+ * - Otherwise, the trait is equivalent to @c boost::conversion::explicit_converter<Target,Source>.
+ */
+ template <class Source, class Target>
+ struct is_extrinsically_explicitly_convertible {};
+
+ //! Macro defined if and only if the compiler doesn't support the features needed to define the @c is_extrinsically_explicitly_convertible type trait for classes.
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE
+
+ }
+}
+#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_reference.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/fusion/tuple.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
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE
+ #endif
+ #elif defined __clang__
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_DECLTYPE
+ //#define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_SIZEOF
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 7 )
+ #if ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_SIZEOF
+ #else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE
+ #endif
+ #else
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_DECLTYPE
+ #endif
+ #else
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_DECLTYPE
+ #endif
+#elif ! defined BOOST_NO_SFINAE_EXPR
+ #define BOOST_CONVERSION_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_SIZEOF
+ #if defined __clang__
+ #elif defined __GNUC__
+ #endif
+#else
+ #define BOOST_CONVERSION_NO_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE
+#endif
+
+#if ! defined BOOST_NO_RVALUE_REFERENCES
+ #if defined _MSC_VER
+ #elif defined __clang__
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_RVALUE
+ #elif defined __GNUC__
+ #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_RVALUE
+ #endif
+ #else
+ #define BOOST_CONVERSION_TT_IS_EXTRINSICALLY_EXPLICITLY_CONVERTIBLE_USES_RVALUE
+ #endif
+#endif
+
+namespace boost {
+ namespace conversion {
+ namespace detail {
+ namespace is_extrinsically_explicitly_convertible {
+
+ 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_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_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_EXTRINSICALLY_EXPLICITLY_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 conversion::is_extrinsically_explicitly_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, 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_explicitly_convertible
+ } // detail
+
+ template <class Source, class Target>
+ struct is_extrinsically_explicitly_convertible
+ : public detail::is_extrinsically_explicitly_convertible::imp<Source, Target> {};
+
+ template <class T>
+ struct is_extrinsically_explicitly_convertible<fusion::void_,T> : false_type {};
+ }
+}
+
+#endif // doc
+#endif // header
+
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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -65,12 +65,12 @@
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>.
+ //! Specialization for @c try_assigner when @c is_extrinsically_explicitly_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>
+ //! @Requires @c is_extrinsically_explicitly_convertible<Source,Target>
template < typename Target, typename Source >
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-17 18:21:24 EDT (Wed, 17 Aug 2011)
@@ -38,7 +38,7 @@
#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/conversion/is_extrinsically_explicitly_convertible.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/utility/enable_if.hpp>
@@ -64,19 +64,19 @@
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>.
+ //! Specialization for @c try_converter when @c is_extrinsically_explicitly_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>
+ //! @Requires @c is_extrinsically_explicitly_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
+ is_extrinsically_explicitly_convertible<Source,Target>::value
>::type
#endif
> : true_type