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

Subject: [Boost-commit] svn:boost r73865 - sandbox/conversion/libs/conversion_ext/test
From: vicente.botet_at_[hidden]
Date: 2011-08-17 18:18:19

Author: viboes
Date: 2011-08-17 18:18:18 EDT (Wed, 17 Aug 2011)
New Revision: 73865
URL: http://svn.boost.org/trac/boost/changeset/73865

Log:
conversion: change explicit_ by explictly_
Text files modified: 
   sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp                             |     6                                         
   sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp                             |     2                                         
   sandbox/conversion/libs/conversion_ext/test/is_extrinsically_explicit_convertible.cpp |   614 ++++++++++++++++++++--------------------
   sandbox/conversion/libs/conversion_ext/test/string.cpp                                |     4                                         
   sandbox/conversion/libs/conversion_ext/test/tuple.cpp                                 |     2                                         
   5 files changed, 314 insertions(+), 314 deletions(-)

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-08-17 18:18:18 EDT (Wed, 17 Aug 2011)
@@ -128,7 +128,7 @@
 
 BOOST_STATIC_ASSERT(( !boost::is_convertible< X,ICF_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::conversion::is_extrinsically_explicitly_convertible< X,ICF_X >::value));
 
 struct ECF_X {};
 BOOST_CONVERSION_DCL_DEFAULTS(ECF_X)
@@ -193,9 +193,9 @@
 
 
   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_explicitly_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::conversion::is_extrinsically_explicitly_convertible< X , ICF_X >::value));
   BOOST_STATIC_ASSERT(( boost::is_copy_assignable< ICF_X >::value));
   BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< ICF_X, X >::value));
 

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-08-17 18:18:18 EDT (Wed, 17 Aug 2011)
@@ -121,7 +121,7 @@
 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::conversion::is_extrinsically_convertible< X,ECF_X >::value));
-BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X,ECF_X >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible< X,ECF_X >::value));
 BOOST_STATIC_ASSERT(( ! boost::is_explicitly_convertible< X,AF_X >::value));
 BOOST_STATIC_ASSERT(( ! boost::conversion::is_extrinsically_convertible< X,AF_X >::value));
 

Modified: sandbox/conversion/libs/conversion_ext/test/is_extrinsically_explicit_convertible.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/is_extrinsically_explicit_convertible.cpp	(original)
+++ sandbox/conversion/libs/conversion_ext/test/is_extrinsically_explicit_convertible.cpp	2011-08-17 18:18:18 EDT (Wed, 17 Aug 2011)
@@ -10,7 +10,7 @@
 
 #include <iostream>
 #include <boost/static_assert.hpp>
-#include <boost/conversion/is_extrinsically_explicit_convertible.hpp>
+#include <boost/conversion/is_extrinsically_explicitly_convertible.hpp>
 
 struct A
 {
@@ -32,8 +32,8 @@
 {
   namespace conversion {
 
-  template <> struct is_extrinsically_explicit_convertible< int, A >  : true_type {};
-  template <> struct is_extrinsically_explicit_convertible< double, A >  : true_type {};
+  template <> struct is_extrinsically_explicitly_convertible< int, A >  : true_type {};
+  template <> struct is_extrinsically_explicitly_convertible< double, A >  : true_type {};
   //template <> struct is_constructible< A, int, double >  : true_type {};
   //template <> struct is_constructible< A, A const& >  : true_type {};
 }
@@ -43,373 +43,373 @@
 int main()
 {
   {
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<const int, int>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<int, A>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<double, A>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void,A>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<const int, int>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<int, A>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<double, A>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void,A>::value));
   }
   {
 
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<void, void>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const void, void>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<void, const void>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const void, const void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<void, void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const void, void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<void, const void>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const void, const void>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, Function>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, Function&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, Function*const >::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, Function*const >::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, const Array>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, const char&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<void, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const void, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<void, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const void, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, const void>::value));
 
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, Function>::value));
 
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function, Function&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function, Function&>::value));
 
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function, Function* const>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function, Function* const>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, const Array>::value));
 
 
     BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_convertible<Function, Array&>::value));
     BOOST_STATIC_ASSERT((!boost::is_explicitly_convertible<Function, Array&>::value));
-    BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, const Array&>::value));
+    BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, const char&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, const void>::value));
 
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, Function>::value));
 
     //BOOST_STATIC_ASSERT(( boost::is_explicitly_convertible<Function&, Function&>::value));
     BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<Function&, Function&>::value));
-    // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function&, Function&>::value));
+    // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function&, Function&>::value));
 
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function&, Function*>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function&, Function* const>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function&, Function*>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function&, Function* const>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, const Array>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, const char&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function&, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function&, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, const void>::value));
 
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, Function>::value));
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, Function>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, Function>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, Function&>::value));
 
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function*, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function*, Function* const>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function*const, Function*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Function*const, Function*const >::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function*, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function*, Function* const>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function*const, Function*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Function*const, Function*const >::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, const Array>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, const char&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Function*const, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Function*const, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, const void>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, Function>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, Function&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, Function*const >::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, Function*const >::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, const Array>::value));
 
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, Array&>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, Array&>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const Array, const Array&>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, Array&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, Array&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const Array, const Array&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, const char>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, const char&>::value));
 
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const Array, const char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const Array, const char*>::value));
   }
   {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, const void>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, Function>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, Function&>::value));
 
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, Function*const >::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, Function*const >::value));
 
 #if ! defined _MSC_VER
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, const Array>::value));
 #endif
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array&, Array&>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array&, const Array&>::value));
-  // BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, Array&>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const Array&, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<Array&, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, const char&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array&, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<Array&, const char*>::value));
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const Array&, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const Array&, const char*>::value));
-  }
-  {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, const Array&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char, char>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char, const char>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char, char>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char, const char>::value));
-
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, char&>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char, const char&>::value));
-  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, char&>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char, const char&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char, const char*>::value));
-  }
-  {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, const Array&>::value));
-
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char&, char>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char&, const char>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char&, char>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char&, const char>::value));
-
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char&, char&>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char&, const char&>::value));
-  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, char&>::value));
-  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char&, const char&>::value));
-
-  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, char*>::value));
-  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char&, const char*>::value));
-  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, char*>::value));
-  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char&, const char*>::value));
-  }
-  {
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, const void>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, const void>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, Function>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, Function>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, Function&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, Function&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, Function* const>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, Function*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, Function*const >::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, const Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, Array>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, const Array>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, const Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, Array&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, const Array&>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, const char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, char>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, const char>::value));
-
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<char*, const char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, char&>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, const char&>::value));
-
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char*, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<char*, const char*>::value));
-  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const char*, char*>::value));
-  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<const char*, const char*>::value));
-  }
-  {
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<NonCopyable&, NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<NonCopyable&, const NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<NonCopyable&, volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<const NonCopyable&, const NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<const NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value));
-  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicit_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value));
-  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicit_convertible<const NonCopyable&, NonCopyable&>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array&, Array&>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array&, const Array&>::value));
+  // BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, Array&>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const Array&, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<Array&, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, const char&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array&, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<Array&, const char*>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const Array&, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const Array&, const char*>::value));
+  }
+  {
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, const Array&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char, char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char, const char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char, char>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char, const char>::value));
+
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, char&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char, const char&>::value));
+  //BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, char&>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char, const char&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char, const char*>::value));
+  }
+  {
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, const Array&>::value));
+
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char&, char>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char&, const char>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char&, char>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char&, const char>::value));
+
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char&, char&>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char&, const char&>::value));
+  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, char&>::value));
+  // BUG BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char&, const char&>::value));
+
+  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, char*>::value));
+  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char&, const char*>::value));
+  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, char*>::value));
+  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char&, const char*>::value));
+  }
+  {
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, const void>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, const void>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, Function>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, Function>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, Function&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, Function&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, Function* const>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, Function*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, Function*const >::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, const Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, Array>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, const Array>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, const Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, Array&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, const Array&>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, const char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, char>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, const char>::value));
+
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<char*, const char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, char&>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, const char&>::value));
+
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char*, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<char*, const char*>::value));
+  BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const char*, char*>::value));
+  BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<const char*, const char*>::value));
+  }
+  {
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<NonCopyable&, NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<NonCopyable&, const NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<NonCopyable&, volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<const NonCopyable&, const NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<const NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value));
+  BOOST_STATIC_ASSERT((boost::conversion::is_extrinsically_explicitly_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value));
+  // BUG BOOST_STATIC_ASSERT((!boost::conversion::is_extrinsically_explicitly_convertible<const NonCopyable&, NonCopyable&>::value));
   }
 }

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-08-17 18:18:18 EDT (Wed, 17 Aug 2011)
@@ -27,8 +27,8 @@
 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::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_explicitly_convertible<std::string, bool >::value));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_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));
 

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-08-17 18:18:18 EDT (Wed, 17 Aug 2011)
@@ -23,7 +23,7 @@
 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::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));
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicitly_convertible<fusion::tuple<B1,B2>, fusion::tuple<A1,A2> >::value));
 
 
 void explicit_convert_to() {