passenger_dudemeister 3.0.1

data/ext/boost/type_traits/is_base_of.hpp

@@ -0,0 +1,51 @@
+
+//  (C) Copyright Rani Sharoni 2003-2005.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+ 
+#ifndef BOOST_TT_IS_BASE_OF_HPP_INCLUDED
+#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/type_traits/detail/ice_and.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+   namespace detail{
+      template <class B, class D>
+      struct is_base_of_imp
+      {
+          typedef typename remove_cv<B>::type ncvB;
+          typedef typename remove_cv<D>::type ncvD;
+          BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or<      
+            (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value),
+            (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value));
+      };
+   }
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(
+      is_base_of
+    , Base
+    , Derived
+    , (::boost::detail::is_base_of_imp<Base, Derived>::value))
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false)
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false)
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED

data/ext/boost/type_traits/is_class.hpp

@@ -0,0 +1,140 @@
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000-2003.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_IS_CLASS_HPP_INCLUDED
+#define BOOST_TT_IS_CLASS_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+#ifndef BOOST_IS_CLASS
+#   include <boost/type_traits/is_union.hpp>
+#   include <boost/type_traits/detail/ice_and.hpp>
+#   include <boost/type_traits/detail/ice_not.hpp>
+
+#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
+#   include <boost/type_traits/detail/yes_no_type.hpp>
+#else
+#   include <boost/type_traits/is_scalar.hpp>
+#   include <boost/type_traits/is_array.hpp>
+#   include <boost/type_traits/is_reference.hpp>
+#   include <boost/type_traits/is_void.hpp>
+#   include <boost/type_traits/is_function.hpp>
+#endif
+
+#endif // BOOST_IS_CLASS
+
+#ifdef __EDG_VERSION__
+#   include <boost/type_traits/remove_cv.hpp>
+#endif
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+#ifndef BOOST_IS_CLASS
+#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
+
+// This is actually the conforming implementation which works with
+// abstract classes.  However, enough compilers have trouble with
+// it that most will use the one in
+// boost/type_traits/object_traits.hpp. This implementation
+// actually works with VC7.0, but other interactions seem to fail
+// when we use it.
+
+// is_class<> metafunction due to Paul Mensonides
+// (leavings@attbi.com). For more details:
+// http://groups.google.com/groups?hl=en&selm=000001c1cc83%24e154d5e0%247772e50c%40c161550a&rnum=1
+#if defined(__GNUC__)  && !defined(__EDG_VERSION__)
+
+template <class U> ::boost::type_traits::yes_type is_class_tester(void(U::*)(void));
+template <class U> ::boost::type_traits::no_type is_class_tester(...);
+
+template <typename T>
+struct is_class_impl
+{
+
+    BOOST_STATIC_CONSTANT(bool, value =
+        (::boost::type_traits::ice_and<
+            sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type),
+            ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value
+        >::value)
+        );
+};
+
+#else
+
+template <typename T>
+struct is_class_impl
+{
+    template <class U> static ::boost::type_traits::yes_type is_class_tester(void(U::*)(void));
+    template <class U> static ::boost::type_traits::no_type is_class_tester(...);
+
+    BOOST_STATIC_CONSTANT(bool, value =
+        (::boost::type_traits::ice_and<
+            sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type),
+            ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value
+        >::value)
+        );
+};
+
+#endif
+
+#else
+
+template <typename T>
+struct is_class_impl
+{
+#   ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    BOOST_STATIC_CONSTANT(bool, value =
+    (::boost::type_traits::ice_and<
+        ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_scalar<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
+        ::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_function<T>::value >::value
+        >::value));
+#   else
+    BOOST_STATIC_CONSTANT(bool, value =
+    (::boost::type_traits::ice_and<
+        ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_scalar<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
+        ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
+        ::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value
+        >::value));
+#   endif
+};
+
+# endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
+# else // BOOST_IS_CLASS
+template <typename T>
+struct is_class_impl
+{
+    BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_CLASS(T));
+};
+# endif // BOOST_IS_CLASS
+
+} // namespace detail
+
+# ifdef __EDG_VERSION__
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+   is_class,T, boost::detail::is_class_impl<typename boost::remove_cv<T>::type>::value)
+# else 
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_class,T,::boost::detail::is_class_impl<T>::value)
+# endif
+    
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_CLASS_HPP_INCLUDED

data/ext/boost/type_traits/is_const.hpp

@@ -0,0 +1,165 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, 
+//      Howard Hinnant and John Maddock 2000. 
+//  (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001
+
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+//    Fixed is_pointer, is_reference, is_const, is_volatile, is_same, 
+//    is_member_pointer based on the Simulated Partial Specialization work 
+//    of Mat Marcus and Jesse Jones. See  http://opensource.adobe.com or 
+//    http://groups.yahoo.com/group/boost/message/5441 
+//    Some workarounds in here use ideas suggested from "Generic<Programming>: 
+//    Mappings between Types and Values" 
+//    by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
+
+
+#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED
+#define BOOST_TT_IS_CONST_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#   include <boost/type_traits/detail/cv_traits_impl.hpp>
+#   ifdef __GNUC__
+#       include <boost/type_traits/is_reference.hpp>
+#   endif
+#   if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+#       include <boost/type_traits/remove_bounds.hpp>
+#   endif
+#else
+#   include <boost/type_traits/is_reference.hpp>
+#   include <boost/type_traits/is_array.hpp>
+#   include <boost/type_traits/detail/yes_no_type.hpp>
+#   include <boost/type_traits/detail/false_result.hpp>
+#endif
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+#if defined( __CODEGEARC__ )
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T))
+
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+namespace detail{
+//
+// We can't filter out rvalue_references at the same level as
+// references or we get ambiguities from msvc:
+//
+template <class T>
+struct is_const_rvalue_filter
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+	BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_const);
+#else
+	BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<T*>::is_const);
+#endif
+};
+#ifndef BOOST_NO_RVALUE_REFERENCES
+template <class T>
+struct is_const_rvalue_filter<T&&>
+{
+	BOOST_STATIC_CONSTANT(bool, value = false);
+};
+#endif
+}
+
+//* is a type T  declared const - is_const<T>
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_rvalue_filter<T>::value)
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false)
+
+#if  defined(BOOST_ILLEGAL_CV_REFERENCES)
+// these are illegal specialisations; cv-qualifies applied to
+// references have no effect according to [8.3.2p1],
+// C++ Builder requires them though as it treats cv-qualified
+// references as distinct types...
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const,false)
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& volatile,false)
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false)
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ < 3)
+// special case for gcc where illegally cv-qualified reference types can be
+// generated in some corner cases:
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T const,!(::boost::is_reference<T>::value))
+BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T volatile const,!(::boost::is_reference<T>::value))
+#endif
+
+#else
+
+namespace detail {
+
+using ::boost::type_traits::yes_type;
+using ::boost::type_traits::no_type;
+
+yes_type is_const_tester(const volatile void*);
+no_type is_const_tester(volatile void *);
+
+template <bool is_ref, bool array>
+struct is_const_helper
+    : ::boost::type_traits::false_result
+{
+};
+
+template <>
+struct is_const_helper<false,false>
+{
+    template <typename T> struct result_
+    {
+        static T* t;
+        BOOST_STATIC_CONSTANT(bool, value = (
+            sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(t))
+            ));
+    };
+};
+
+template <>
+struct is_const_helper<false,true>
+{
+    template <typename T> struct result_
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(bool, value = (
+            sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(&t))
+            ));
+    };
+};
+
+template <typename T>
+struct is_const_impl
+    : is_const_helper<
+          is_reference<T>::value
+        , is_array<T>::value
+        >::template result_<T>
+{
+};
+
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void,false)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void volatile,false)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const volatile,true)
+#endif
+
+} // namespace detail
+
+//* is a type T  declared const - is_const<T>
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_impl<T>::value)
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_CONST_HPP_INCLUDED
+

data/ext/boost/type_traits/is_convertible.hpp

@@ -0,0 +1,430 @@
+
+// Copyright 2000 John Maddock (john@johnmaddock.co.uk)
+// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu)
+// Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED
+#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED
+
+#include <boost/type_traits/intrinsics.hpp>
+#ifndef BOOST_IS_CONVERTIBLE
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_void.hpp>
+#ifndef BOOST_NO_IS_ABSTRACT
+#include <boost/type_traits/is_abstract.hpp>
+#endif
+
+#if defined(__MWERKS__)
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#endif
+
+#endif // BOOST_IS_CONVERTIBLE
+
+// should be always the last #include directive
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+#ifndef BOOST_IS_CONVERTIBLE
+
+// is one type convertable to another?
+//
+// there are multiple versions of the is_convertible
+// template, almost every compiler seems to require its
+// own version.
+//
+// Thanks to Andrei Alexandrescu for the original version of the
+// conversion detection technique!
+//
+
+namespace detail {
+
+// MS specific version:
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
+
+// This workaround is necessary to handle when From is void
+// which is normally taken care of by the partial specialization
+// of the is_convertible typename.
+using ::boost::type_traits::yes_type;
+using ::boost::type_traits::no_type;
+
+template< typename From >
+struct does_conversion_exist
+{
+    template< typename To > struct result_
+    {
+        static no_type BOOST_TT_DECL _m_check(...);
+        static yes_type BOOST_TT_DECL _m_check(To);
+        static From _m_from;
+        enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) };
+    };
+};
+
+template<>
+struct does_conversion_exist<void>
+{
+    template< typename To > struct result_
+    {
+        enum { value = ::boost::is_void<To>::value };
+    };
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl
+    : does_conversion_exist<From>::template result_<To>
+{
+};
+
+#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560)
+//
+// special version for Borland compilers
+// this version breaks when used for some
+// UDT conversions:
+//
+template <typename From, typename To>
+struct is_convertible_impl
+{
+#pragma option push -w-8074
+    // This workaround for Borland breaks the EDG C++ frontend,
+    // so we only use it for Borland.
+    template <typename T> struct checker
+    {
+        static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...);
+        static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(T);
+    };
+
+    static From _m_from;
+    static bool const value = sizeof( checker<To>::_m_check(_m_from) )
+        == sizeof(::boost::type_traits::yes_type);
+#pragma option pop
+};
+
+#elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+// special version for gcc compiler + recent Borland versions
+// note that this does not pass UDT's through (...)
+
+struct any_conversion
+{
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+};
+
+template <typename T> struct checker
+{
+    static boost::type_traits::no_type _m_check(any_conversion ...);
+    static boost::type_traits::yes_type _m_check(T, int);
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+    static From _m_from;
+    static bool const value = sizeof( boost::detail::checker<To>::_m_check(_m_from, 0) )
+        == sizeof(::boost::type_traits::yes_type);
+};
+
+#elif (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL)) \
+      || defined(__IBMCPP__) || defined(__HP_aCC)
+//
+// This is *almost* an ideal world implementation as it doesn't rely
+// on undefined behaviour by passing UDT's through (...).
+// Unfortunately it doesn't quite pass all the tests for most compilers (sigh...)
+// Enable this for your compiler if is_convertible_test.cpp will compile it...
+//
+// Note we do not enable this for VC7.1, because even though it passes all the
+// type_traits tests it is known to cause problems when instantiation occurs
+// deep within the instantiation tree :-(
+//
+struct any_conversion
+{
+    template <typename T> any_conversion(const volatile T&);
+    // we need this constructor to catch references to functions
+    // (which can not be cv-qualified):
+    template <typename T> any_conversion(T&);
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+    static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...);
+    static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int);
+       static From _m_from;
+
+    BOOST_STATIC_CONSTANT(bool, value =
+        sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type)
+        );
+};
+
+#elif defined(__DMC__)
+
+struct any_conversion
+{
+    template <typename T> any_conversion(const volatile T&);
+    // we need this constructor to catch references to functions
+    // (which can not be cv-qualified):
+    template <typename T> any_conversion(T&);
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+    // Using '...' doesn't always work on Digital Mars. This version seems to.
+    template <class T>
+    static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion,  float, T);
+    static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int, int);
+    static From _m_from;
+
+    // Static constants sometime cause the conversion of _m_from to To to be
+    // called. This doesn't happen with an enum.
+    enum { value =
+        sizeof( _m_check(_m_from, 0, 0) ) == sizeof(::boost::type_traits::yes_type)
+        };
+};
+
+#elif defined(__MWERKS__)
+// 
+// CW works with the technique implemented above for EDG, except when From
+// is a function type (or a reference to such a type), in which case
+// any_conversion won't be accepted as a valid conversion. We detect this
+// exceptional situation and channel it through an alternative algorithm.
+//
+
+template <typename From, typename To,bool FromIsFunctionRef>
+struct is_convertible_basic_impl_aux;
+
+struct any_conversion
+{
+    template <typename T> any_conversion(const volatile T&);
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl_aux<From,To,false /*FromIsFunctionRef*/>
+{
+    static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...);
+    static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int);
+    static From _m_from;
+
+    BOOST_STATIC_CONSTANT(bool, value =
+        sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type)
+        );
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl_aux<From,To,true /*FromIsFunctionRef*/>
+{
+    static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...);
+    static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To);
+    static From _m_from;
+    BOOST_STATIC_CONSTANT(bool, value =
+        sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type)
+        );
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl:
+  is_convertible_basic_impl_aux<
+    From,To,
+    ::boost::is_function<typename ::boost::remove_reference<From>::type>::value
+  >
+{};
+
+#else
+
+//
+// This version seems to work pretty well for a wide spectrum of compilers,
+// however it does rely on undefined behaviour by passing UDT's through (...).
+//
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+    static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...);
+    static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To);
+    static From _m_from;
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4244)
+#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
+#pragma warning(disable:6334)
+#endif
+#endif
+    BOOST_STATIC_CONSTANT(bool, value =
+        sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type)
+        );
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+};
+
+#endif // is_convertible_impl
+
+#if defined(__DMC__)
+// As before, a static constant sometimes causes errors on Digital Mars.
+template <typename From, typename To>
+struct is_convertible_impl
+{
+    typedef typename add_reference<From>::type ref_type;
+    enum { value =
+        (::boost::type_traits::ice_and<
+            ::boost::type_traits::ice_or<
+               ::boost::detail::is_convertible_basic_impl<ref_type,To>::value,
+               ::boost::is_void<To>::value
+            >::value,
+            ::boost::type_traits::ice_not<
+               ::boost::is_array<To>::value
+            >::value
+        >::value) };
+};
+#elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551
+template <typename From, typename To>
+struct is_convertible_impl
+{
+    typedef typename add_reference<From>::type ref_type;
+    BOOST_STATIC_CONSTANT(bool, value =
+        (::boost::type_traits::ice_and<
+            ::boost::type_traits::ice_or<
+               ::boost::detail::is_convertible_basic_impl<ref_type,To>::value,
+               ::boost::is_void<To>::value
+            >::value,
+            ::boost::type_traits::ice_not<
+               ::boost::is_array<To>::value
+            >::value
+        >::value)
+        );
+};
+#endif
+
+template <bool trivial1, bool trivial2, bool abstract_target>
+struct is_convertible_impl_select
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef is_convertible_impl<From, To> type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<true, true, false>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef true_type type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<false, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<true, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch_base
+{
+#if !BOOST_WORKAROUND(__HP_aCC, < 60700)
+   typedef is_convertible_impl_select< 
+      ::boost::is_arithmetic<From>::value, 
+      ::boost::is_arithmetic<To>::value,
+#ifndef BOOST_NO_IS_ABSTRACT
+      ::boost::is_abstract<To>::value
+#else
+      false
+#endif
+   > selector;
+#else
+   typedef is_convertible_impl_select<false, false, false> selector;
+#endif
+   typedef typename selector::template rebind<From, To> isc_binder;
+   typedef typename isc_binder::type type;
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch 
+   : public is_convertible_impl_dispatch_base<From, To>::type
+{};
+
+//
+// Now add the full and partial specialisations
+// for void types, these are common to all the
+// implementation above:
+//
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+#   define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 volatile,value) \
+    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const volatile,value) \
+    /**/
+
+#   define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(trait,spec1,spec2,value) \
+    TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \
+    TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const,spec2,value) \
+    TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 volatile,spec2,value) \
+    TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const volatile,spec2,value) \
+    /**/
+
+    TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(is_convertible,void,void,true)
+
+#   undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2
+#   undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1
+
+#else
+    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true)
+#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,true)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const,To,false)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void volatile,To,false)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const volatile,To,false)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,true)
+#endif
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,(::boost::detail::is_convertible_impl_dispatch<From,To>::value))
+
+#else
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,BOOST_IS_CONVERTIBLE(From,To))
+
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED