[Boost-commit] svn:boost r73867 - in sandbox/conversion/boost/conversion: . boost detail

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