[Boost-commit] svn:boost r73032 - sandbox/conversion/libs/conversion_ext/test

Subject: [Boost-commit] svn:boost r73032 - sandbox/conversion/libs/conversion_ext/test
From: vicente.botet_at_[hidden]
Date: 2011-07-13 00:41:07

Author: viboes
Date: 2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
New Revision: 73032
URL: http://svn.boost.org/trac/boost/changeset/73032

Log:
conversion: rename is_extrinsic_ by is_intrinsically_
Text files modified: 
   sandbox/conversion/libs/conversion_ext/test/Jamfile.v2                   |     2                                         
   sandbox/conversion/libs/conversion_ext/test/array.cpp                    |     8                                         
   sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp                |    22                                         
   sandbox/conversion/libs/conversion_ext/test/helper.hpp                   |    12                                         
   sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp                |     6                                         
   sandbox/conversion/libs/conversion_ext/test/is_extrinsic_assignable.cpp  |     2                                         
   sandbox/conversion/libs/conversion_ext/test/is_extrinsic_convertible.cpp |   644 ++++++++++++++++++++--------------------
   sandbox/conversion/libs/conversion_ext/test/pair.cpp                     |     8                                         
   sandbox/conversion/libs/conversion_ext/test/string.cpp                   |    12                                         
   sandbox/conversion/libs/conversion_ext/test/tuple.cpp                    |     4                                         
   sandbox/conversion/libs/conversion_ext/test/vector.cpp                   |     4                                         
   11 files changed, 362 insertions(+), 362 deletions(-)

Modified: sandbox/conversion/libs/conversion_ext/test/Jamfile.v2
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/Jamfile.v2	(original)
+++ sandbox/conversion/libs/conversion_ext/test/Jamfile.v2	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -80,7 +80,7 @@
      [ run ../example/no_throw.cpp ]
      [ run ../example/fallback.cpp ]
      [ run ../example/overload.cpp ]
-     [ run ../example/formatted.cpp ]
+     #[ run ../example/formatted.cpp ]
     ;
 
 

Modified: sandbox/conversion/libs/conversion_ext/test/array.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/array.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/array.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -17,11 +17,11 @@
 
 #if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( boost::is_assignable< int&, short const&>::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< int, short >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< int, short >::value));
 BOOST_STATIC_ASSERT(( boost::is_assignable< short&, int const& >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< short, int >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< A1, B1 >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< boost::array<A1,3>, boost::array<B1,3> >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< short, int >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< A1, B1 >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< boost::array<A1,3>, boost::array<B1,3> >::value));
 #endif
 
 using namespace boost;

Modified: sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -16,7 +16,7 @@
 #include <boost/conversion/convertible_to.hpp>
 #include <boost/conversion/convertible_from.hpp>
 #include <boost/conversion/assignable_to.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_convertible.hpp>
+#include <boost/conversion/is_extrinsically_convertible.hpp>
 #include <iostream>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/static_assert.hpp>
@@ -86,8 +86,8 @@
   }
 #endif
 
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< B,A >::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< C,B >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible< B,A >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible< C,B >::value));
 
 
   void f(B) {}
@@ -99,7 +99,7 @@
   }
 
   template <typename T>
-  typename boost::enable_if<boost::is_extrinsic_convertible<T,B>, void >::type
+  typename boost::enable_if<boost::conversion::is_extrinsically_convertible<T,B>, void >::type
   h(T v)
   {
     return f(convert_to<B>(v));
@@ -125,9 +125,9 @@
 }
 
 BOOST_STATIC_ASSERT(( !boost::is_convertible< X,ICF_X >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< X,ICF_X >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible< X,ICF_X >::value));
 #if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible< X,ICF_X >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X,ICF_X >::value));
 #endif
 
 struct ECF_X {};
@@ -193,12 +193,12 @@
 
 
 #if defined(BOOST_CONVERSION_ENABLE_CND)
-  BOOST_STATIC_ASSERT(( !boost::is_extrinsic_convertible< X,AF_X >::value));
-  BOOST_STATIC_ASSERT(( !boost::is_extrinsic_explicit_convertible< X,AF_X >::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< X , ICF_X >::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible< X , ICF_X >::value));
+  BOOST_STATIC_ASSERT(( !boost::conversion::is_extrinsically_convertible< X,AF_X >::value));
+  BOOST_STATIC_ASSERT(( !boost::conversion::is_extrinsically_explicit_convertible< X,AF_X >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible< X , ICF_X >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X , ICF_X >::value));
   BOOST_STATIC_ASSERT(( boost::is_copy_assignable< ICF_X >::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< ICF_X, X >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< ICF_X, X >::value));
 
 #endif
 

Modified: sandbox/conversion/libs/conversion_ext/test/helper.hpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/helper.hpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/helper.hpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -17,8 +17,8 @@
 #include <boost/conversion/type_traits/is_constructible.hpp>
 #include <boost/conversion/type_traits/is_explicitly_convertible.hpp>
 #include <boost/conversion/type_traits/is_assignable.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_convertible.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_assignable.hpp>
+#include <boost/conversion/is_extrinsically_convertible.hpp>
+#include <boost/conversion/is_extrinsically_assignable.hpp>
 
 #if defined(BOOST_CONVERSION_NO_IS_DEFAULT_CONSTRUCTIBLE) || defined(BOOST_CONVERSION_NO_IS_CONSTRUCTIBLE) || defined(BOOST_CONVERSION_NO_IS_ASSIGNABLE)
 #define BOOST_CONVERSION_DCL_DEFAULTS(X)                              \
@@ -96,15 +96,15 @@
 #endif
 #endif
 
-    BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<B1, A1>::value));
-    BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<B2, A2>::value));
+    BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<B1, A1>::value));
+    BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<B2, A2>::value));
 
 
     #if defined(BOOST_CONVERSION_ENABLE_CND)
     BOOST_STATIC_ASSERT(( !boost::is_assignable<A1, B1>::value));
     BOOST_STATIC_ASSERT(( !boost::is_assignable<A2, B2>::value));
-    BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable<A1, B1>::value));
-    BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable<A2, B2>::value));
+    BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<A1, B1>::value));
+    BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<A2, B2>::value));
     #endif
 
 

Modified: sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -112,14 +112,14 @@
 #if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( ! boost::is_convertible< X,ECF_X >::value));
 BOOST_STATIC_ASSERT(( boost::is_explicitly_convertible< X,ECF_X >::value));
-BOOST_STATIC_ASSERT(( ! boost::is_extrinsic_convertible< X,ECF_X >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible< X,ECF_X >::value));
+BOOST_STATIC_ASSERT(( ! boost::conversion::is_extrinsically_convertible< X,ECF_X >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X,ECF_X >::value));
 #endif
 
 
 #if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( ! boost::is_explicitly_convertible< X,AF_X >::value));
-BOOST_STATIC_ASSERT(( ! boost::is_extrinsic_convertible< X,AF_X >::value));
+BOOST_STATIC_ASSERT(( ! boost::conversion::is_extrinsically_convertible< X,AF_X >::value));
 #endif
 
 //////////////////////////

Modified: sandbox/conversion/libs/conversion_ext/test/is_extrinsic_assignable.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/is_extrinsic_assignable.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/is_extrinsic_assignable.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -11,7 +11,7 @@
 
 #include <iostream>
 #include <boost/static_assert.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_assignable.hpp>
+#include <boost/conversion/is_extrinsically_assignable.hpp>
 
 
 

Modified: sandbox/conversion/libs/conversion_ext/test/is_extrinsic_convertible.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/is_extrinsic_convertible.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/is_extrinsic_convertible.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -11,7 +11,7 @@
 
 #include <iostream>
 #include <boost/static_assert.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_convertible.hpp>
+#include <boost/conversion/is_extrinsically_convertible.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 
 
@@ -27,360 +27,360 @@
 {
 
   {
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<void, void>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const void, void>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<void, const void>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const void, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, const char&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<void, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const void, const char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<void, void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const void, void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<void, const void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const void, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, const char&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<void, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const void, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, const void>::value));
 
-  //BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, Function>::value));
 
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function, Function&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function, Function&>::value));
 
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function, Function* const>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function, Function* const>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, const Array>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, const char&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, const void>::value));
 
-  //BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, Function>::value));
 
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function&, Function&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function&, Function&>::value));
 
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function&, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function&, Function* const>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function&, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function&, Function* const>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, const Array>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, const char&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function&, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function&, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, const void>::value));
-
-  //BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, Function>::value));
-  //BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, Function&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function*, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function*, Function* const>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function*const, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Function*const, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, const char&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Function*const, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, const void>::value));
+
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, Function&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function*, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function*, Function* const>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function*const, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function*const, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, const char&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function*const, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, const Array>::value));
-
-  //BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, Array&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, Array&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const Array, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, const char&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const Array, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, const Array>::value));
+
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, Array&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, Array&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const Array, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, const char&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const Array, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, const Array>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array&, Array&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array&, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, Array&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const Array&, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<Array&, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, const char&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array&, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<Array&, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const Array&, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const Array&, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, const Array>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array&, Array&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array&, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, Array&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const Array&, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Array&, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, const char&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array&, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Array&, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const Array&, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const Array&, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, const Array&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char, char>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char, const char>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char, char>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char, const char>::value));
-
-  //BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, char&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, char&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char, const char&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, const Array&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char, char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char, const char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char, char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char, const char>::value));
+
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, char&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, char&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char, const char&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, const Array&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char&, char>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char&, const char>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char&, char>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char&, const char>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char&, char&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char&, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, char&>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char&, const char&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char&, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char&, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, const Array&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char&, char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char&, const char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char&, char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char&, const char>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char&, char&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char&, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, char&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char&, const char&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char&, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char&, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, char>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<char*, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, const char&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char*, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<char*, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const char*, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<const char*, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<char*, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, const char&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char*, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<char*, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const char*, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<const char*, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<NonCopyable&, NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<NonCopyable&, const NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<NonCopyable&, volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<const NonCopyable&, const NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<const NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::is_extrinsic_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((!boost::is_extrinsic_convertible<const NonCopyable&, NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<NonCopyable&, NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<NonCopyable&, const NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<NonCopyable&, volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<const NonCopyable&, const NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<const NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<const NonCopyable&, NonCopyable&>::value));
   }
 }

Modified: sandbox/conversion/libs/conversion_ext/test/pair.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/pair.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/pair.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -19,8 +19,8 @@
 #include <boost/conversion/type_traits/is_constructible.hpp>
 #include <boost/conversion/type_traits/is_explicitly_convertible.hpp>
 #include <boost/conversion/type_traits/is_assignable.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_convertible.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_assignable.hpp>
+#include <boost/conversion/is_extrinsically_convertible.hpp>
+#include <boost/conversion/is_extrinsically_assignable.hpp>
 
 using namespace boost;
 
@@ -31,10 +31,10 @@
 #endif
 
 #if defined(BOOST_CONVERSION_ENABLE_CND)
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<std::pair<B1,B2>, std::pair<A1,A2> >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<std::pair<B1,B2>, std::pair<A1,A2> >::value));
 BOOST_STATIC_ASSERT(( !boost::is_assignable<std::pair<A1,A2>, std::pair<B1,B2> >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::assigner<std::pair<A1,A2>, std::pair<B1,B2> >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable<std::pair<A1,A2>, std::pair<B1,B2> >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<std::pair<A1,A2>, std::pair<B1,B2> >::value));
 #endif
 
 void explicit_convert_to() {

Modified: sandbox/conversion/libs/conversion_ext/test/string.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/string.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/string.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -13,8 +13,8 @@
 #include <boost/conversion/assign_to.hpp>
 #include <boost/conversion/std/string.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_convertible.hpp>
-#include <boost/conversion/type_traits/is_extrinsic_assignable.hpp>
+#include <boost/conversion/is_extrinsically_convertible.hpp>
+#include <boost/conversion/is_extrinsically_assignable.hpp>
 
 
 using namespace boost;
@@ -28,10 +28,10 @@
 BOOST_STATIC_ASSERT(( boost::is_copy_assignable<std::string >::value));
 BOOST_STATIC_ASSERT(( !boost::is_assignable<std::string, bool >::value));
 BOOST_STATIC_ASSERT(( !boost::is_assignable<bool, std::string >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible<std::string, bool >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible<bool, std::string>::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable<std::string, bool >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable<bool, std::string >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<std::string, bool >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<bool, std::string>::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<std::string, bool >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<bool, std::string >::value));
 #endif
 
 void explicit_convert_to() {

Modified: sandbox/conversion/libs/conversion_ext/test/tuple.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/tuple.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/tuple.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -23,8 +23,8 @@
 BOOST_STATIC_ASSERT(( boost::is_assignable<fusion::tuple<A1,A2>, fusion::tuple<A1,A2> >::value));
 BOOST_STATIC_ASSERT(( boost::is_assignable<fusion::tuple<A1,A2>&, fusion::tuple<A1,A2> const&>::value));
 BOOST_STATIC_ASSERT(( boost::is_copy_assignable<boost::fusion::tuple<A1,A2> >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable<fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible<fusion::tuple<B1,B2>, fusion::tuple<A1,A2> >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<fusion::tuple<B1,B2>, fusion::tuple<A1,A2> >::value));
 #endif
 
 

Modified: sandbox/conversion/libs/conversion_ext/test/vector.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/vector.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/vector.cpp	2011-07-13 00:41:05 EDT (Wed, 13 Jul 2011)
@@ -19,8 +19,8 @@
 using namespace boost;
 
 #if defined(BOOST_CONVERSION_ENABLE_CND)
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< A1, B1 >::value));
-BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< std::vector<A1>, std::vector<B1> >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< A1, B1 >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< std::vector<A1>, std::vector<B1> >::value));
 #endif
 
 #if 0