[Boost-commit] svn:boost r73778 - in sandbox/conversion/boost/conversion: . fp type_traits

Subject: [Boost-commit] svn:boost r73778 - in sandbox/conversion/boost/conversion: . fp type_traits
From: vicente.botet_at_[hidden]
Date: 2011-08-15 12:47:04

Author: viboes
Date: 2011-08-15 12:47:01 EDT (Mon, 15 Aug 2011)
New Revision: 73778
URL: http://svn.boost.org/trac/boost/changeset/73778

Log:
conversion: update comments
Text files modified: 
   sandbox/conversion/boost/conversion/assign_to.hpp                             |    14 ++++++++++++++                          
   sandbox/conversion/boost/conversion/convert_to.hpp                            |    15 ++++++---------                         
   sandbox/conversion/boost/conversion/convert_to_or_fallback.hpp                |    12 ++++++++++++                            
   sandbox/conversion/boost/conversion/explicit_convert_to.hpp                   |     8 ++++----                                
   sandbox/conversion/boost/conversion/fp/convert_to.hpp                         |    18 ++++++++++++++----                      
   sandbox/conversion/boost/conversion/implicit_convert_to.hpp                   |     6 +++---                                  
   sandbox/conversion/boost/conversion/is_extrinsically_assignable.hpp           |    12 +++++++++---                            
   sandbox/conversion/boost/conversion/is_extrinsically_convertible.hpp          |     6 +++++-                                  
   sandbox/conversion/boost/conversion/is_extrinsically_explicit_convertible.hpp |     6 +++++-                                  
   sandbox/conversion/boost/conversion/try_assign_to.hpp                         |    28 +++++++++++++++++++++-------            
   sandbox/conversion/boost/conversion/try_convert_to.hpp                        |    28 ++++++++++++++++++++++------            
   sandbox/conversion/boost/conversion/type_traits/is_assignable.hpp             |    33 ++++++++++++++++++++++++---------       
   sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp          |    17 ++++++++++++-----                       
   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  |     5 ++++-                                   
   sandbox/conversion/boost/conversion/type_traits/is_destructible.hpp           |    16 +++++++++++-----                        
   sandbox/conversion/boost/conversion/type_traits/is_explicitly_convertible.hpp |    11 ++++++++---                             
   sandbox/conversion/boost/conversion/type_traits/is_move_assignable.hpp        |    11 +++++++++--                             
   sandbox/conversion/boost/conversion/type_traits/is_move_constructible.hpp     |    10 ++++++++--                              
   20 files changed, 193 insertions(+), 67 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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -15,6 +15,20 @@
  *
  * The function @c assign_to assigns the @c from parameter to the @c to parameter.
  *
+ * The default behavior uses the assignment operator when the @c Target is assignable from the @c Source,
+ * or makes an implicit conversion of the @ Source before assignment when the @c Source is
+ * implicitly convertible to @c Target.
+ *
+ * When the default behavior is not satisfactory or doesn't takes care of
+ *  specific types, the user could customize the behavior of
+ *  @c assign_to in two ways:
+ *
+ *    - overload the @c assign_to on any namespace found by ADL from the
+ *  @c Source or the @c Target.
+ *    - partially specialize the @c boost::conversion::assigner_cp struct.
+ *
+ *  @note As we can not add new functions on the @c std namespace, partial
+ *  specialization is the only option in these cases.
  */
 
 #ifndef BOOST_CONVERSION_ASSIGN_TO_HPP

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -20,19 +20,12 @@
 
 
 #include <boost/conversion/explicit_convert_to.hpp>
+#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
 
 namespace boost {
 
   namespace conversion {
-    //! meta-function to state if the parameter is a place_holder
-    //!
-    //! @tparam T The type to check for.
-    //! @tparam Enable A dummy parameter that can be used for SFINAE.
 
-    //! The nested type @c type is @c false_type or @c true_type which default to @c false_type.
-    //!   Specific specialization would make this meta-function to be @c true_type.
-    template <typename T, typename Enabled=void>
-    struct enable_functor : false_type {};
 
 
     //! @brief Extrinsic conversion function.
@@ -50,7 +43,11 @@
     //! This function doesn't participate on overload resolution when @c conversion::enable_functor<Source>::type is mpl::true_.
     template <typename Target, typename Source>
 #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-    typename disable_if<typename conversion::enable_functor<Source>::type, Target>::type
+    //typename disable_if<typename conversion::enable_functor<Source>::type, Target>::type
+    typename enable_if_c<
+      conversion::is_extrinsically_explicit_convertible<Source,Target>::value,
+      Target
+    >::type
 #else
     Target
 #endif

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -22,6 +22,18 @@
  *  @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.
+ *
+ * When the default behavior is not satisfactory or doesn't takes care of
+ *  specific types, the user could customize the behavior of
+ *  @c convert_to_or_fallback in two ways:
+ *
+ *    - overload the @c convert_to_or_fallback 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::converter_or_fallbacker_cp struct.
+ *
+ *  @note As we can not add new functions on the @c std namespace, partial
+ *  specialization is the only option in these cases.
  */
 
 #ifndef BOOST_CONVERSION_CONVERT_TO_OR_FALLBACK_HPP

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -19,17 +19,17 @@
  * 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
+ * When the default behavior is not satisfactory or doesn't takes care of
  *  specific types, the user could customize the behavior of
  *  @c explicit_convert_to in two ways:
  *
- *  * overload the @c explicit_convert_to on any namespace found by ADL from the
+ *    - 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.
+ *    - 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.
+ *  specialization is the only option in these cases.
  */
 
 #ifndef BOOST_CONVERSION_EXPLICIT_CONVERT_TO_HPP

Modified: sandbox/conversion/boost/conversion/fp/convert_to.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/fp/convert_to.hpp	(original)
+++ sandbox/conversion/boost/conversion/fp/convert_to.hpp	2011-08-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -40,6 +40,16 @@
 
 namespace boost { 
   namespace conversion {
+#if 1
+    //! meta-function to state if the parameter is a place_holder
+    //!
+    //! @tparam T The type to check for.
+    //! @tparam Enable A dummy parameter that can be used for SFINAE.
+
+    //! The nested type @c type is @c false_type or @c true_type which default to @c false_type.
+    //!   Specific specialization would make this meta-function to be @c true_type.
+    template <typename T, typename Enabled=void>
+    struct enable_functor : false_type {};
 
     //! @c enable_functor meta-function specialization for types @c T satisfying @c phoenix::is_actor<T>.
 
@@ -53,6 +63,7 @@
 #endif
     >  : true_type {};
 
+#endif
     namespace detail {
       struct convert_to_eval
       {
@@ -128,14 +139,13 @@
     template <typename Target, typename Source>
     inline
 #if !defined(BOOST_CONVERSION_DOXYGEN_INVOKED)
-    typename enable_if<typename boost::conversion::enable_functor<Source>::type,
+    typename enable_if_c<phoenix::is_actor<Source>::value,
       typename expression::convert_to<boost::phoenix::detail::target<Target>, Source>::type const
     >::type
 #else
-    typename enable_if<typename boost::conversion::enable_functor<Source>::type,
-      typename expression::convert_to<boost::phoenix::detail::target<Target>, Source>::type const
+    typename enable_if_c<phoenix::is_actor<Source>::value,
+    unspecified_converter_type
     >::type
-    //unspecified_converter_type
 #endif
     convert_to(Source const& u)
     {

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -23,13 +23,13 @@
  *  specific types, the user could customize the behavior of
  *  @c implicit_convert_to in two ways:
  *
- *  * overload the @c implicit_convert_to on any namespace found by ADL from the
+ *    - overload the @c implicit_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::implicit_converter_cp struct.
+ *    - partially specialize the @c boost::conversion::implicit_converter_cp struct.
  *
  *  @note As we can not add new functions on the @c std namespace, partial
- *  specialization is the only option.
+ *  specialization is the only option in these cases.
  *
  */
 #ifndef BOOST_CONVERSION_IMPLICIT_CONVERT_TO_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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -21,19 +21,25 @@
     /**
      * 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
+     * @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.
      *
+     * @Remark
+     *   - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation.
+     *   - Otherwise, the trait is equivalent to @c boost::conversion::assigner<Target,Source>.
+     *
      */
     template <typename Target, typename Source>
     struct is_extrinsically_assignable {};
 
-  //! 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
+    //! Macro stating if the compiler doesn't support the features needed to define the @c is_extrinsically_assignable type trait.
+    #define BOOST_CONVERSION_NO_IS_EXTRINSIC_ASSIGNABLE
 
   }
 }

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -21,14 +21,18 @@
     /**
      * 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
+     * @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.
      *
+     * @Remark
+     *   - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation.
+     *   - Otherwise, the trait is equivalent to @c boost::conversion::implicit_converter<Target,Source>.
      */
     template <typename Source, typename Target>
     struct is_extrinsically_convertible {};

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -21,14 +21,18 @@
     /**
      * 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
+     * @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_explicit_convertible {};

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -7,13 +7,27 @@
 // See http://www.boost.org/libs/conversion for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-/*!
- @file
- @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.
-
+/**
+ *  @file
+ *  @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 default behavior stores a roll-back value before doing the assignment so the value can be rolled-back if assignment fails
+ * when the @c Source is extrinsically assignable to the @c Target.
+ *
+ * When the default behavior is not satisfactory or doesn't takes care of
+ *  specific types, the user could customize the behavior of
+ *  @c try_assign_to in two ways:
+ *
+ *    - overload the @c try_assign_to on any namespace found by ADL from the
+ *  @c Source or the @c Target.
+ *    - partially specialize the @c boost::conversion::try_assigner_cp struct.
+ *
+ *  @note As we can not add new functions on the @c std namespace, partial
+ *  specialization is the only option in these cases.
  */
 
 #ifndef BOOST_CONVERSION_TRY_ASSIGN_TO_HPP

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -7,12 +7,28 @@
 // See http://www.boost.org/libs/conversion for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-/*!
- @file
- @brief
- Defines the free function @c try_convert_to and its customization point @c try_converter.
-
- 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.
+/**
+ *  @file
+ *  @brief
+ *  Defines the free function @c try_convert_to and its customization point @c try_converter.
+ *
+ *  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.
+ *
+ * The default behavior return a make_optional of the conversion when the @c Source is extrinsically explicit convertible to the @c Target.
+ * A try_catch is used to protect from exceptions, and return an uninitialized optional if conversion fails.
+ *
+ * When the default behavior is not satisfactory or doesn't takes care of
+ *  specific types, the user could customize the behavior of
+ *  @c try_convert_to in two ways:
+ *
+ *    - overload the @c try_assign_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::try_converter_cp struct.
+ *
+ *  @note As we can not add new functions on the @c std namespace, partial
+ *  specialization is the only option in these cases.
  
  */
 

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -21,15 +21,27 @@
   /**
    * 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
+   * @Condition: @c true_type if <c>declval<Target>() = declval<Source>()</c> is well-formed when treated as an
    * unevaluated operand.
    *
    * @Requires @c Target and @c Source must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
+   *
+   * @Remark
+   *   - On compilers providing an intrinsic for this trait, the intrinsic will be used.
+   *   - On C++0x mode, @c std::is_assignable will be used when available.
+   *   - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation.
+   *   - Otherwise,
+   *     - the library will provide specialization for the builtin types in this file,
+   *     - the library will provide specialization for specific standard types in the associated @c type_traits/std/file.hpp
+   *     - the library will provide specialization for specific boost types in the associated @c type_traits/boost/file.hpp
+   *     - the user will need to provide other specific specializations.
    */
   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.
+
+  //! Macro stating if the compiler doesn't support the features needed to provide a valid implementation of @c is_assignable type trait.
+  //! In this case the user needs to provide specific specializations.
   #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
 }
 #else
@@ -51,21 +63,20 @@
 #endif
 
 #if defined(BOOST_IS_ASSIGNABLE)
-#define BOOST_CONVERSION_IS_ASSIGNABLE_USES_INTRINSICS
+  #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__
     //#define BOOST_CONVERSION_IS_ASSIGNABLE_USES_DECLTYPE
     #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
-    //#define BOOST_CONVERSION_NO_IS_ASSIGNABLE
   #elif defined __GNUC__
      #if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
-#if ! defined BOOST_NO_SFINAE_EXPR
-#define BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
-#else
-#define BOOST_CONVERSION_NO_IS_ASSIGNABLE
-#endif
+        #if ! defined BOOST_NO_SFINAE_EXPR
+          #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_SIZEOF
+        #else
+          #define BOOST_CONVERSION_NO_IS_ASSIGNABLE
+        #endif
     #else
        #define BOOST_CONVERSION_IS_ASSIGNABLE_USES_DECLTYPE
      #endif
@@ -128,6 +139,7 @@
               , true_type()))
 #if    1
           selector(int);
+          // I don't know why the following code doesn't works.
 #elif defined    BOOST_CONVERSION_TT_IS_ASSIGNABLE_USES_RVALUE
           selector(T1&&, S1&&);
 #else
@@ -137,11 +149,13 @@
           static false_type
 #if    1
           selector(...);
+          // I don't know why the following code doesn't works.
 #elif defined  BOOST_CONVERSION_TT_IS_ASSIGNABLE_USES_RVALUE
           selector(any, S1&&);
 #else
           selector(any, S1&);
 #endif
+          // I don't know why the following code doesn't works.
           //static const bool value =
           //  sizeof(selector<T,S>(0)) ==
           //  sizeof(yes_type);
@@ -149,6 +163,7 @@
 #if    1
           typedef decltype(selector<T,S>(0)) type;
 #else
+          // I don't know why the following code doesn't works.
           typedef decltype(selector(declval<T>(), declval<S>())) type;
 #endif
         };

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -22,7 +22,7 @@
   /**
    * States if @c T is constructible from @c Args.
    *
-   * Condition: @c true_type if and only if the following variable definition would be well-formed for
+   * @Condition: @c true_type if and only if the following variable definition would be well-formed for
    * some invented variable t:
    *
    * @code
@@ -30,6 +30,17 @@
    * @endcode
    *
    * @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.
+   *
+   * @Remark
+   *   - On compilers providing an intrinsic for this trait, the intrinsic will be used.
+   *   - On C++0x mode, @c std::is_constructible will be used when available.
+   *   - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation.
+   *   - Otherwise,
+   *     - the library will provide specialization for the builtin types in this file,
+   *     - the library will provide specialization for specific standard types in the associated @c type_traits/std/file.hpp
+   *     - the library will provide specialization for specific boost types in the associated @c type_traits/boost/file.hpp
+   *     - the user will need to provide other specific specializations.
+   *
    */
   template < typename T, typename... Args>
   struct is_constructible
@@ -75,12 +86,8 @@
 
 #if ! defined BOOST_NO_DECLTYPE
   #if defined _MSC_VER
-    #if ! defined BOOST_NO_SFINAE_EXPR
-      #define BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_SIZEOF
-    #else
       #define BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE
       #define BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE
-    #endif
   #elif defined __clang__
     #define BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_DECLTYPE
   #elif defined __GNUC__

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -25,7 +25,7 @@
   /**
    * States if @c T is copy assignable.
    *
-   * Condition: <c>is_assignable<T&, T const&>::value</c> is @c true.
+   * @Condition: <c>is_assignable<T&, T const&>::value</c> is @c true.
    *
    * @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
    */

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -26,7 +26,7 @@
   /**
    * States if @c T is copy constructible.
    *
-   * Condition: <c>is_constructible<T, T const&>::value</c> is @c true.
+   * @Condition: <c>is_constructible<T, T const&>::value</c> is @c true.
    *
    * @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
    */

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -26,9 +26,12 @@
   /**
    * States if @c T is default constructible.
    *
-   * Condition: <c>is_constructible<T>::value</c> is @c true.
+   * @Condition: <c>is_constructible<T>::value</c> is @c true.
    *
    * @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
+   *
+   * @Remark
+   *   - @see BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE
    */
   template <typename T>
   struct is_default_constructible : is_constructible<

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -20,7 +20,7 @@
   /**
    * States if @c T is destructible.
    *
-   * Condition: @c true_type if and only if given:
+   * @Condition: @c true_type if and only if given:
    *
    * @code
    *   template <typename U>
@@ -38,6 +38,16 @@
    * is well formed;
    *
    * @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
+   *
+   * @Remark
+   *   - On compilers providing an intrinsic for this trait, the intrinsic will be used.
+   *   - On C++0x mode, @c std::is_destructible will be used when available.
+   *   - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation.
+   *   - Otherwise,
+   *     - the library will provide specialization for the builtin types in this file,
+   *     - the library will provide specialization for specific standard types in the associated @c type_traits/std/file.hpp
+   *     - the library will provide specialization for specific boost types in the associated @c type_traits/boost/file.hpp
+   *     - the user will need to provide other specific specializations.
    */
   template <typename T>
   struct is_destructible
@@ -63,11 +73,7 @@
 
 #if ! defined BOOST_NO_DECLTYPE
   #if defined _MSC_VER
-    #if ! defined BOOST_NO_SFINAE_EXPR
-      #define BOOST_CONVERSION_IS_DESTRUCTIBLE_USES_SIZEOF
-    #else
       #define BOOST_CONVERSION_NO_IS_DESTRUCTIBLE
-    #endif
   #elif defined __clang__
     #define BOOST_CONVERSION_IS_DESTRUCTIBLE_USES_DECLTYPE
   #elif defined __GNUC__

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -22,7 +22,7 @@
   /**
    * States if @c Source is is explicitly convertible to @c Target.
    *
-   * Condition: @c true_type if and only if the following would be well-formed for
+   * @Condition: @c true_type if and only if the following would be well-formed for
    * some invented function test:
    *
    * @code
@@ -34,8 +34,13 @@
    * @Requires @c Source and @c Target must be complete types, (possibly cv-qualified) void, or arrays of unknown bound.
    * @Remark @c is_explicitly_convertible has been removed from the C++0x proposal since
    * <b>N3047 - Fixing is_constructible and is_explicitly_convertible</b>
-   * was accepted. The library provides the @c static_cast version when the compiler supports the needed features,
-   * otherwise it relies on the @c is_constructible version.
+   * was accepted.
+   *
+   * @Remark
+   *   - On compilers providing an intrinsic for this trait, the intrinsic will be used.
+   *   - On C++0x mode, @c std::is_assignable will be used when available.
+   *   - On compilers supporting SFINAE_EXPR or DECLTYPE the library provided a valid implementation using the @c static_cast version
+   *   - Otherwise it relies on the @c is_constructible version.
    */
   template < typename Source, typename Target>
   struct is_explicitly_convertible

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -24,7 +24,7 @@
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/add_lvalue_reference.hpp>
 
-#if ! defined BOOST_NO_RVALUE_REFERENCES
+#if ! defined BOOST_NO_RVALUE_REFERENCES && ! defined BOOST_CONVERSION_DOXYGEN_INVOKED
   #if defined _MSC_VER
   #elif defined __clang__
       #define BOOST_CONVERSION_TT_IS_MOVE_ASSIGNABLE_USES_RVALUE
@@ -45,9 +45,16 @@
   /**
    * States if @c T is move assignable.
    *
-   * Condition: <c>is_assignable<T&, T&&>::value</c> is @c true.
+   * @Condition: <c>is_assignable<T&, T&&>::value</c> is @c true.
    *
    * @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
+   *
+   * @Remark
+   *   - On compilers providing an intrinsic for this trait, the intrinsic will be used.
+   *   - On C++0x mode, @c std::is_move_assignable will be used when available.
+   *   - On compilers supporting RVALUE_REFERENCES the trait is equivalent to <c>is_assignable<T&, T&&></c>.
+   *   - Otherwise, <c>is_copy_assignable<T></c>.
+   *
    */
   template <typename T>
   struct is_move_assignable :

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-15 12:47:01 EDT (Mon, 15 Aug 2011)
@@ -25,7 +25,7 @@
 #include <boost/type_traits/add_rvalue_reference.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
-#if ! defined BOOST_NO_RVALUE_REFERENCES
+#if ! defined BOOST_NO_RVALUE_REFERENCES && ! defined BOOST_CONVERSION_DOXYGEN_INVOKED
   #if defined _MSC_VER
   #elif defined __clang__
       #define BOOST_CONVERSION_TT_IS_MOVE_CONSTRUCTIBLE_USES_RVALUE
@@ -45,9 +45,15 @@
   /**
    * States if @c T is move constructible.
    *
-   * Condition: <c>is_constructible<T, T&&>::value</c> is @c true.
+   * @Condition: <c>is_constructible<T, T&&>::value</c> is @c true.
    *
    * @Requires @c T must be a complete type, (possibly cv-qualified) void, or an array of unknown bound.
+   *
+   * @Remark
+   *   - On compilers providing an intrinsic for this trait, the intrinsic will be used.
+   *   - On C++0x mode, @c std::is_move_constructible will be used when available.
+   *   - On compilers supporting RVALUE_REFERENCES the trait is equivalent to <c>is_assignable<T&, T&&></c>.
+   *
    */
   template <typename T>
   struct is_move_constructible :