Add missing #include.

Add missing copyright.

include/boost/type_traits.hpp

@@ -94,6 +94,8 @@
 #include <boost/type_traits/is_assignable.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_bounded_array.hpp>
+#include <boost/type_traits/is_unbounded_array.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_complex.hpp>
 #include <boost/type_traits/is_compound.hpp>
@@ -160,4 +162,12 @@
 #include <boost/type_traits/promote.hpp>
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_SFINAE_EXPR)
+#include <boost/type_traits/detected.hpp>
+#include <boost/type_traits/is_detected.hpp>
+#include <boost/type_traits/is_detected_convertible.hpp>
+#include <boost/type_traits/is_detected_exact.hpp>
+#include <boost/type_traits/detected_or.hpp>
+#endif
+
 #endif // BOOST_TYPE_TRAITS_HPP

include/boost/type_traits/add_const.hpp

@@ -27,7 +27,7 @@ namespace boost {
 #   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
 #endif 
 
-   template <class T> struct add_const
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_const
    {
       typedef T const type;
    };
@@ -36,14 +36,14 @@ namespace boost {
 #   pragma warning(pop)
 #endif 
 
-   template <class T> struct add_const<T&>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_const<T&>
    {
       typedef T& type;
    };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_const_t = typename add_const<T>::type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_const_t = typename add_const<T>::type;
 
 #endif
 

include/boost/type_traits/add_cv.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_TT_ADD_CV_HPP_INCLUDED
 #define BOOST_TT_ADD_CV_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -28,17 +28,17 @@ namespace boost {
 #   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
 #endif 
 
-template <class T> struct add_cv{ typedef T const volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_cv{ typedef T const volatile type; };
 
 #if defined(BOOST_MSVC)
 #   pragma warning(pop)
 #endif 
 
-template <class T> struct add_cv<T&>{ typedef T& type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_cv<T&>{ typedef T& type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_cv_t = typename add_cv<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_cv_t = typename add_cv<T>::type;
 
 #endif
 

include/boost/type_traits/add_lvalue_reference.hpp

@@ -10,13 +10,13 @@
 
 namespace boost{
 
-template <class T> struct add_lvalue_reference
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_lvalue_reference
 {
    typedef typename boost::add_reference<T>::type type; 
 };
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct add_lvalue_reference<T&&>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_lvalue_reference<T&&>
 {
    typedef T& type;
 };
@@ -24,7 +24,7 @@ template <class T> struct add_lvalue_reference<T&&>
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
 
 #endif
 

include/boost/type_traits/add_pointer.hpp

@@ -47,7 +47,7 @@ struct add_pointer<T&const volatile>
 
 #else
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct add_pointer
 {
     typedef typename remove_reference<T>::type no_ref_type;
@@ -58,7 +58,7 @@ struct add_pointer
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_pointer_t = typename add_pointer<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_pointer_t = typename add_pointer<T>::type;
 
 #endif
 

include/boost/type_traits/add_reference.hpp

@@ -9,8 +9,7 @@
 #ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
 #define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
 
-#include <boost/detail/workaround.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -21,14 +20,14 @@ namespace detail {
 // references or we get ambiguities from msvc:
 //
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct add_reference_impl
 {
     typedef T& type;
 };
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct add_reference_impl<T&&>
 {
     typedef T&& type;
@@ -37,26 +36,26 @@ struct add_reference_impl<T&&>
 
 } // namespace detail
 
-template <class T> struct add_reference
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_reference
 {
    typedef typename boost::detail::add_reference_impl<T>::type type;
 };
-template <class T> struct add_reference<T&>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_reference<T&>
 {
    typedef T& type;
 };
 
 // these full specialisations are always required:
-template <> struct add_reference<void> { typedef void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<void> { typedef void type; };
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct add_reference<const void> { typedef const void type; };
-template <> struct add_reference<const volatile void> { typedef const volatile void type; };
-template <> struct add_reference<volatile void> { typedef volatile void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<const void> { typedef const void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<const volatile void> { typedef const volatile void type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct add_reference<volatile void> { typedef volatile void type; };
 #endif
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-template <class T> using add_reference_t = typename add_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_reference_t = typename add_reference<T>::type;
 
 #endif
 

include/boost/type_traits/add_rvalue_reference.hpp

@@ -8,7 +8,7 @@
 #ifndef BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
 #define BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 //----------------------------------------------------------------------------//
 
@@ -53,14 +53,14 @@ namespace type_traits_detail {
 
 }
 
-template <class T> struct add_rvalue_reference
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_rvalue_reference
 {
    typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
 
 #endif
 

include/boost/type_traits/add_volatile.hpp

@@ -10,7 +10,7 @@
 #ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
 #define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
@@ -27,17 +27,17 @@ namespace boost {
 #   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
 #endif 
 
-template <class T> struct add_volatile{ typedef T volatile type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_volatile{ typedef T volatile type; };
 
 #if defined(BOOST_MSVC)
 #   pragma warning(pop)
 #endif 
 
-template <class T> struct add_volatile<T&>{ typedef T& type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct add_volatile<T&>{ typedef T& type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using add_volatile_t = typename add_volatile<T>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using add_volatile_t = typename add_volatile<T>::type;
 
 #endif
 

include/boost/type_traits/aligned_storage.hpp

@@ -13,10 +13,11 @@
 #ifndef BOOST_TT_ALIGNED_STORAGE_HPP
 #define BOOST_TT_ALIGNED_STORAGE_HPP
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // for std::size_t
+#endif
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/is_pod.hpp>
@@ -26,11 +27,6 @@ namespace boost {
 
 namespace detail { namespace aligned_storage {
 
-BOOST_STATIC_CONSTANT(
-      std::size_t
-    , alignment_of_max_align = ::boost::alignment_of<boost::detail::max_align>::value
-    );
-
 //
 // To be TR1 conforming this must be a POD type:
 //
@@ -68,7 +64,7 @@ struct aligned_storage_imp<0u,alignment_>
 
 }} // namespace detail::aligned_storage
 
-template <
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <
       std::size_t size_
     , std::size_t alignment_ = std::size_t(-1)
 >
@@ -93,7 +89,7 @@ public: // constants
           std::size_t
         , alignment = (
               alignment_ == std::size_t(-1)
-            ? ::boost::detail::aligned_storage::alignment_of_max_align
+            ? ::boost::alignment_of<boost::detail::max_align>::value
             : alignment_
             )
         );
@@ -130,7 +126,7 @@ public: // accessors
 // Make sure that is_pod recognises aligned_storage<>::type
 // as a POD (Note that aligned_storage<> itself is not a POD):
 //
-template <std::size_t size_, std::size_t alignment_>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <std::size_t size_, std::size_t alignment_>
 struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> > : public true_type{};
 
 } // namespace boost

include/boost/type_traits/alignment_of.hpp

@@ -9,9 +9,11 @@
 #ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
 #define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef>
+#endif
 
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
@@ -25,7 +27,7 @@
 
 namespace boost {
 
-template <typename T> struct alignment_of;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct alignment_of;
 
 // get the alignment of some arbitrary type:
 namespace detail {
@@ -85,25 +87,25 @@ struct alignment_of_impl
 
 } // namespace detail
 
-template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
 
 // references have to be treated specially, assume
 // that a reference is just a special pointer:
-template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
 
 #ifdef BOOST_BORLANDC
 // long double gives an incorrect value of 10 (!)
 // unless we do this...
 struct long_double_wrapper{ long double ld; };
-template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
 #endif
 
 // void has to be treated specially:
-template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
-template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
-template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
 #endif
 
 } // namespace boost

include/boost/type_traits/common_type.hpp

@@ -9,14 +9,15 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/decay.hpp>
 #include <boost/type_traits/declval.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/is_complete.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_array.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 #if defined(BOOST_NO_CXX11_DECLTYPE)
 #include <boost/type_traits/detail/common_type_impl.hpp>
@@ -33,13 +34,13 @@ namespace boost
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-template<class... T> struct common_type
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class... T> struct common_type
 {
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-template<class... T> using common_type_t = typename common_type<T...>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class... T> using common_type_t = typename common_type<T...>::type;
 
 namespace type_traits_detail
 {
@@ -48,14 +49,14 @@ template<class T1, class T2, class... T> using common_type_fold = common_type_t<
 
 } // namespace type_traits_detail
 
-template<class T1, class T2, class... T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T1, class T2, class... T>
 struct common_type<T1, T2, T...>: type_traits_detail::mp_defer<type_traits_detail::common_type_fold, T1, T2, T...>
 {
 };
 
 #else
 
-template<class T1, class T2, class... T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T1, class T2, class... T>
 struct common_type<T1, T2, T...>: common_type<typename common_type<T1, T2>::type, T...>
 {
 };
@@ -64,7 +65,7 @@ struct common_type<T1, T2, T...>: common_type<typename common_type<T1, T2>::type
 
 #else
 
-template<
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<
     class T1 = void, class T2 = void, class T3 = void,
     class T4 = void, class T5 = void, class T6 = void,
     class T7 = void, class T8 = void, class T9 = void
@@ -77,7 +78,7 @@ struct common_type: common_type<typename common_type<T1, T2>::type, T3, T4, T5,
 
 // one argument
 
-template<class T> struct common_type<T>: boost::decay<T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct common_type<T>: boost::decay<T>
 {
    BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value || ::boost::is_void<T>::value || ::boost::is_array<T>::value, "Arguments to common_type must both be complete types");
 };
@@ -141,7 +142,7 @@ template<class T1, class T2> struct common_type_decay_helper<T1, T2, T1, T2>: co
 
 } // type_traits_detail
 
-template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
 {
    BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T1>::value || ::boost::is_void<T1>::value || ::boost::is_array<T1>::value, "Arguments to common_type must both be complete types");
    BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T2>::value || ::boost::is_void<T2>::value || ::boost::is_array<T2>::value, "Arguments to common_type must both be complete types");

include/boost/type_traits/conditional.hpp

@@ -9,16 +9,16 @@
 #ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED
 #define BOOST_TT_CONDITIONAL_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-template <bool b, class T, class U> struct conditional { typedef T type; };
-template <class T, class U> struct conditional<false, T, U> { typedef U type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool b, class T, class U> struct conditional { typedef T type; };
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct conditional<false, T, U> { typedef U type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
 
 #endif
 

include/boost/type_traits/conjunction.hpp

@@ -18,19 +18,19 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 namespace boost {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class...>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class...>
 struct conjunction
     : true_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct conjunction<T>
     : T { };
 
-template<class T, class... U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class... U>
 struct conjunction<T, U...>
     : conditional<bool(T::value), conjunction<U...>, T>::type { };
 #else
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct conjunction
     : conditional<bool(T::value), U, T>::type { };
 #endif

include/boost/type_traits/copy_cv.hpp

@@ -18,7 +18,7 @@
 namespace boost
 {
 
-template<class T, class U> struct copy_cv
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U> struct copy_cv
 {
 private:
 
@@ -31,7 +31,7 @@ public:
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
 
 #endif
 

include/boost/type_traits/copy_cv_ref.hpp

@@ -15,14 +15,14 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct copy_cv_ref {
     typedef typename copy_reference<typename copy_cv<T,
         typename remove_reference<U>::type >::type, U>::type type;
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 using copy_cv_ref_t = typename copy_cv_ref<T, U>::type;
 #endif
 

include/boost/type_traits/copy_reference.hpp

@@ -17,7 +17,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct copy_reference {
     typedef typename conditional<is_rvalue_reference<U>::value,
         typename add_rvalue_reference<T>::type,
@@ -26,7 +26,7 @@ struct copy_reference {
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 using copy_reference_t = typename copy_reference<T, U>::type;
 #endif
 

include/boost/type_traits/decay.hpp

@@ -28,7 +28,7 @@ namespace boost
 
    }
 
-    template< class T >
+    BOOST_TYPE_TRAITS_MODULE_EXPORT template< class T >
     struct decay
     {
     private:
@@ -39,7 +39,7 @@ namespace boost
     
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using decay_t = typename decay<T>::type;
+    BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using decay_t = typename decay<T>::type;
 
 #endif
 

include/boost/type_traits/declval.hpp

@@ -8,7 +8,7 @@
 #ifndef BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED
 #define BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 //----------------------------------------------------------------------------//
 
@@ -36,7 +36,7 @@
 
 namespace boost {
 
-    template <typename T>
+    BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
     typename add_rvalue_reference<T>::type declval() BOOST_NOEXCEPT; // as unevaluated operand
 
 }  // namespace boost

include/boost/type_traits/detail/bool_trait_def.hpp

@@ -20,7 +20,7 @@
 
 #include <boost/type_traits/detail/template_arity_spec.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 //
 // Unfortunately some libraries have started using this header without

include/boost/type_traits/detail/common_arithmetic_type.hpp

@@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost
 {

include/boost/type_traits/detail/composite_member_pointer_type.hpp

@@ -13,8 +13,10 @@
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/conditional.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
 #include <cstddef>
+#endif
 
 namespace boost
 {

include/boost/type_traits/detail/composite_pointer_type.hpp

@@ -14,8 +14,10 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_base_of.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
 #include <cstddef>
+#endif
 
 namespace boost
 {

include/boost/type_traits/detail/config.hpp

@@ -9,13 +9,18 @@
 #ifndef BOOST_TT_CONFIG_HPP_INCLUDED
 #define BOOST_TT_CONFIG_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #ifndef BOOST_CONFIG_HPP
 #include <boost/config.hpp>
 #endif
 #include <boost/version.hpp>
 #include <boost/config/workaround.hpp>
+#define BOOST_TYPE_TRAITS_MODULE_EXPORT
+#else
+#define BOOST_STATIC_ASSERT(x) static_assert(x)
+#define BOOST_STATIC_ASSERT_MSG(x, msg) static_assert(x, msg)
+#endif
 
-//
 // whenever we have a conversion function with ellipses
 // it needs to be declared __cdecl to suppress compiler
 // warnings from MS and Borland compilers (this *must*
@@ -112,5 +117,3 @@
 #endif
 
 #endif // BOOST_TT_CONFIG_HPP_INCLUDED
-
-

include/boost/type_traits/detail/has_binary_operator.hpp

@@ -6,7 +6,6 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -38,7 +37,9 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 namespace boost
 {
@@ -70,11 +71,11 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, U, Ret> {};
-   template <class T, class U>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U>
    struct BOOST_TT_TRAIT_NAME<T, U, void> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T, U> {};
-   template <class T, class U>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U>
    struct BOOST_TT_TRAIT_NAME<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T, U> {};
 
 

include/boost/type_traits/detail/has_postfix_operator.hpp

@@ -6,7 +6,6 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
@@ -16,7 +15,9 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 namespace boost
 {
@@ -48,11 +49,11 @@ namespace boost
 
    }
 
-   template <class T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class Ret = boost::binary_op_detail::dont_care>
    struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, Ret> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, void> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T> {};
 
 

include/boost/type_traits/detail/has_prefix_operator.hpp

@@ -6,7 +6,6 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
@@ -16,7 +15,9 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <utility>
+#endif
 
 #ifdef BOOST_GCC
 #pragma GCC diagnostic push
@@ -57,11 +58,11 @@ namespace boost
 
    }
 
-   template <class T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class Ret = boost::binary_op_detail::dont_care>
    struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, Ret> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, void> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct BOOST_TT_TRAIT_NAME<T, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T> {};
 
 

include/boost/type_traits/detail/is_function_cxx_11.hpp

@@ -15,7 +15,7 @@
 
 namespace boost {
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_function : public false_type {};
 
 #if defined(__cpp_noexcept_function_type) && !defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM)
@@ -33,313 +33,313 @@ namespace boost {
 #endif
    
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
    
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
    
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)&& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)&& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_X64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
    
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)&&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
@@ -354,310 +354,310 @@ namespace boost {
 #define BOOST_TT_NOEXCEPT_DECL noexcept
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
 #if !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret BOOST_TT_DEF_CALL(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
-   template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __stdcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __clrcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __fastcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_function<Ret __vectorcall(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif

include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp

@@ -14,7 +14,9 @@
 #ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
 #define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
+#endif
 
 #if defined(BOOST_TT_PREPROCESSING_MODE)
 //

include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp

@@ -22,13 +22,13 @@ namespace boost {
 #endif
 
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer : public false_type {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer<T const> : public is_member_function_pointer<T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer<T volatile> : public is_member_function_pointer<T> {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_member_function_pointer<T const volatile> : public is_member_function_pointer<T> {};
 
 #if defined(BOOST_TT_NO_DEDUCED_NOEXCEPT_PARAM)
@@ -44,318 +44,318 @@ namespace boost {
 #define BOOST_TT_NOEXCEPT_DECL
 #endif
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (C::*)(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (BOOST_TT_DEF_CALL C::*)(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__clrcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
  
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
  
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__stdcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__fastcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret (__vectorcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
@@ -368,318 +368,318 @@ namespace boost {
 #undef BOOST_TT_NOEXCEPT_DECL
 #define BOOST_TT_NOEXCEPT_DECL noexcept
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // Reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)& BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
    // rvalue reference qualified:
 
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const qualified:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // volatile:
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
    // const volatile
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(BOOST_TT_DEF_CALL C::*)(Args...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class ...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile &BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // rvalue reference qualified:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...) && BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif
 
    // const volatile:
 #if !defined(_M_X64) && !defined(_M_CEE_SAFE) && !defined(_M_CEE_PURE)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__stdcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__cdecl C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #ifdef _MANAGED
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__clrcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #else
 #ifndef _M_AMD64
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__fastcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #if defined(_M_IX86_FP) && (_M_IX86_FP >= 2) || defined(_M_X64)
-   template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ret, class C, class...Args BOOST_TT_NOEXCEPT_PARAM>
    struct is_member_function_pointer<Ret(__vectorcall C::*)(Args...)const volatile &&BOOST_TT_NOEXCEPT_DECL> : public true_type {};
 #endif
 #endif

include/boost/type_traits/detected.hpp

@@ -15,7 +15,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<template<class...> class Op, class... Args>
 using detected_t = typename
     detail::detector<nonesuch, void, Op, Args...>::type;
 

include/boost/type_traits/detected_or.hpp

@@ -14,10 +14,10 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class Default, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Default, template<class...> class Op, class... Args>
 using detected_or = detail::detector<Default, void, Op, Args...>;
 
-template<class Default, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Default, template<class...> class Op, class... Args>
 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
 
 } /* boost */

include/boost/type_traits/disjunction.hpp

@@ -18,19 +18,19 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 namespace boost {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class...>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class...>
 struct disjunction
     : false_type { };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct disjunction<T>
     : T { };
 
-template<class T, class... U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class... U>
 struct disjunction<T, U...>
     : conditional<bool(T::value), T, disjunction<U...> >::type { };
 #else
-template<class T, class U>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class U>
 struct disjunction
     : conditional<bool(T::value), T, U>::type { };
 #endif

include/boost/type_traits/enable_if.hpp

@@ -15,20 +15,20 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_TT_ENABLE_IF_HPP_INCLUDED
 #define BOOST_TT_ENABLE_IF_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-template<bool B, class T = void>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<bool B, class T = void>
 struct enable_if_ {
     typedef T type;
 };
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct enable_if_<false, T> { };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<bool B, class T = void>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<bool B, class T = void>
 using enable_if_t = typename enable_if_<B, T>::type;
 #endif
 

include/boost/type_traits/extent.hpp

@@ -10,9 +10,10 @@
 #ifndef BOOST_TT_EXTENT_HPP_INCLUDED
 #define BOOST_TT_EXTENT_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/detail/workaround.hpp>
 
 namespace boost {
 
@@ -128,7 +129,7 @@ struct extent_imp<T const volatile[], 0>
 #endif  // non-CodeGear implementation
 }   // ::boost::detail
 
-template <class T, std::size_t N = 0>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N = 0>
 struct extent
    : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
 {

include/boost/type_traits/floating_point_promotion.hpp

@@ -6,19 +6,19 @@
 #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
 #define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 namespace boost {
 
-   template<class T> struct floating_point_promotion { typedef T type; };
-   template<> struct floating_point_promotion<float> { typedef double type; };
-   template<> struct floating_point_promotion<float const> { typedef double const type; };
-   template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
-   template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct floating_point_promotion { typedef T type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float> { typedef double type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float const> { typedef double const type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
-   template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type;
 
 #endif
 

include/boost/type_traits/function_traits.hpp

@@ -9,7 +9,7 @@
 #ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 #define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_function.hpp>
 #include <boost/type_traits/add_pointer.hpp>
 
@@ -163,7 +163,7 @@ struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
 
 } // end namespace detail
 
-template<typename Function>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<typename Function>
 struct function_traits : 
   public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
 {

include/boost/type_traits/has_minus.hpp

@@ -9,7 +9,6 @@
 #ifndef BOOST_TT_HAS_MINUS_HPP_INCLUDED
 #define BOOST_TT_HAS_MINUS_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -87,7 +86,7 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct has_minus : 
       public boost::binary_op_detail::has_minus_void_ptr_filter<
          T, U, Ret, 

include/boost/type_traits/has_minus_assign.hpp

@@ -9,7 +9,6 @@
 #ifndef BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -88,7 +87,7 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct has_minus_assign :
       public boost::binary_op_detail::has_minus_assign_void_ptr_filter<
       T, U, Ret,

include/boost/type_traits/has_new_operator.hpp

@@ -9,11 +9,16 @@
 #ifndef BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
 #define BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <new> // std::nothrow_t
 #include <cstddef> // std::size_t
+#include <boost/detail/workaround.hpp>
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
+
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/detail/workaround.hpp>
 
 #if defined(new) 
 #  if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
@@ -136,7 +141,7 @@ namespace detail {
     };
 } // namespace detail
 
-template <class T> struct has_new_operator : public integral_constant<bool, ::boost::detail::has_new_operator_impl<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_new_operator : public integral_constant<bool, ::boost::detail::has_new_operator_impl<T>::value>{};
 
 } // namespace boost
 

include/boost/type_traits/has_nothrow_assign.hpp

@@ -9,12 +9,16 @@
 #ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 
-#if !defined(BOOST_HAS_NOTHROW_ASSIGN) || defined(BOOST_MSVC) || defined(BOOST_INTEL)
+#if (defined(BOOST_MSVC) || defined(BOOST_INTEL) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES))
 #include <boost/type_traits/has_trivial_assign.hpp>
+#endif
+#if !defined(BOOST_HAS_NOTHROW_ASSIGN)
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_const.hpp>
@@ -49,9 +53,9 @@ namespace boost {
 
 #endif
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct has_nothrow_assign : public integral_constant < bool,
-#ifndef BOOST_HAS_NOTHROW_ASSIGN
+#if !defined(BOOST_HAS_NOTHROW_ASSIGN)
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       // Portable C++11 version:
       detail::has_nothrow_assign_imp<T, 
@@ -66,17 +70,17 @@ namespace boost {
 #endif
    > {};
 
-template <class T, std::size_t N> struct has_nothrow_assign <T[N]> : public has_nothrow_assign<T> {};
-template <> struct has_nothrow_assign<void> : public false_type{};
-template <class T> struct has_nothrow_assign<T volatile> : public false_type{};
-template <class T> struct has_nothrow_assign<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_nothrow_assign <T[N]> : public has_nothrow_assign<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_assign<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_assign<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T> struct has_nothrow_assign<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_assign<T&&> : public false_type{};
 #endif
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_nothrow_assign<void const> : public false_type{};
-template <> struct has_nothrow_assign<void const volatile> : public false_type{};
-template <> struct has_nothrow_assign<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_assign<void volatile> : public false_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/has_nothrow_constructor.hpp

@@ -9,11 +9,13 @@
 #ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
 #define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
-#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR
+#if defined(BOOST_HAS_NOTHROW_CONSTRUCTOR)
 
 #if defined(BOOST_MSVC) || defined(BOOST_INTEL)
 #include <boost/type_traits/has_trivial_constructor.hpp>
@@ -24,7 +26,7 @@
 
 namespace boost {
 
-template <class T> struct has_nothrow_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_CONSTRUCTOR(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_CONSTRUCTOR(T)>{};
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT)
 
@@ -43,7 +45,7 @@ namespace boost { namespace detail{
    template <class T, std::size_t N> struct has_nothrow_constructor_imp<T[N], true> : public has_nothrow_constructor_imp<T, true> {};
 }
 
-template <class T> struct has_nothrow_constructor : public detail::has_nothrow_constructor_imp<T, is_default_constructible<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_constructor : public detail::has_nothrow_constructor_imp<T, is_default_constructible<T>::value>{};
 
 #ifdef BOOST_MSVC
 #pragma warning(pop)
@@ -55,18 +57,18 @@ template <class T> struct has_nothrow_constructor : public detail::has_nothrow_c
 
 namespace boost {
 
-template <class T> struct has_nothrow_constructor : public ::boost::has_trivial_constructor<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_constructor : public ::boost::has_trivial_constructor<T> {};
 
 #endif
 
-template<> struct has_nothrow_constructor<void> : public false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void> : public false_type {};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct has_nothrow_constructor<void const> : public false_type{};
-template<> struct has_nothrow_constructor<void const volatile> : public false_type{};
-template<> struct has_nothrow_constructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_nothrow_constructor<void volatile> : public false_type{};
 #endif
 
-template <class T> struct has_nothrow_default_constructor : public has_nothrow_constructor<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_default_constructor : public has_nothrow_constructor<T>{};
 
 } // namespace boost
 

include/boost/type_traits/has_nothrow_copy.hpp

@@ -12,7 +12,7 @@
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
-#ifdef BOOST_HAS_NOTHROW_COPY
+#if defined(BOOST_HAS_NOTHROW_COPY)
 
 #if defined(BOOST_CLANG) || defined(__GNUC__) || defined(__ghs__) || defined(BOOST_CODEGEARC) || defined(__SUNPRO_CC)
 #include <boost/type_traits/is_volatile.hpp>
@@ -33,7 +33,7 @@
 
 namespace boost {
 
-template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_COPY(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_COPY(T)>{};
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT)
 
@@ -51,7 +51,7 @@ struct has_nothrow_copy_constructor_imp<T, true> : public boost::integral_consta
 
 }
 
-template <class T> struct has_nothrow_copy_constructor : public detail::has_nothrow_copy_constructor_imp<T, boost::is_copy_constructible<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor : public detail::has_nothrow_copy_constructor_imp<T, boost::is_copy_constructible<T>::value>{};
 
 #else
 
@@ -59,23 +59,23 @@ template <class T> struct has_nothrow_copy_constructor : public detail::has_noth
 
 namespace boost{
 
-template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, ::boost::has_trivial_copy<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, ::boost::has_trivial_copy<T>::value>{};
 
 #endif
 
-template <> struct has_nothrow_copy_constructor<void> : public false_type{};
-template <class T> struct has_nothrow_copy_constructor<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor<T volatile> : public false_type{};
 template <class T> struct has_nothrow_copy_constructor<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-template <class T> struct has_nothrow_copy_constructor<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy_constructor<T&&> : public false_type{};
 #endif
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_nothrow_copy_constructor<void const> : public false_type{};
-template <> struct has_nothrow_copy_constructor<void volatile> : public false_type{};
-template <> struct has_nothrow_copy_constructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_copy_constructor<void const volatile> : public false_type{};
 #endif
 
-template <class T> struct has_nothrow_copy : public has_nothrow_copy_constructor<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_copy : public has_nothrow_copy_constructor<T>{};
 
 } // namespace boost
 

include/boost/type_traits/has_nothrow_destructor.hpp

@@ -9,14 +9,16 @@
 #ifndef BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
 #define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
 
-#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(__SUNPRO_CC) && !(defined(BOOST_MSVC) && (_MSC_FULL_VER < 190023506))
 
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_destructible.hpp>
 #include <boost/type_traits/is_complete.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost{
 
@@ -29,22 +31,24 @@ namespace boost{
 
    }
 
-   template <class T> struct has_nothrow_destructor : public detail::has_nothrow_destructor_imp<T, boost::is_destructible<T>::value>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_destructor : public detail::has_nothrow_destructor_imp<T, boost::is_destructible<T>::value>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to has_nothrow_destructor must be complete types");
    };
-   template <class T, std::size_t N> struct has_nothrow_destructor<T[N]> : public has_nothrow_destructor<T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_nothrow_destructor<T[N]> : public has_nothrow_destructor<T>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to has_nothrow_destructor must be complete types");
    };
-   template <class T> struct has_nothrow_destructor<T&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_destructor<T&> : public integral_constant<bool, false>{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-   template <class T> struct has_nothrow_destructor<T&&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_nothrow_destructor<T&&> : public integral_constant<bool, false>{};
 #endif
-   template <> struct has_nothrow_destructor<void> : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_nothrow_destructor<void> : public false_type {};
 }
 #else
 
+#include <boost/type_traits/has_trivial_destructor.hpp>
+
 namespace boost {
 
 template <class T> struct has_nothrow_destructor : public ::boost::has_trivial_destructor<T> {};

include/boost/type_traits/has_plus_assign.hpp

@@ -9,7 +9,6 @@
 #ifndef BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
@@ -91,7 +90,7 @@ namespace boost
 
    }
 
-   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
    struct has_plus_assign : public boost::binary_op_detail:: has_plus_assign_filter_impossible <T, U, Ret, boost::is_arithmetic<typename boost::remove_reference<T>::type>::value && boost::is_pointer<typename remove_reference<U>::type>::value && !boost::is_same<bool, typename boost::remove_cv<typename remove_reference<T>::type>::type>::value> {};
 
 }

include/boost/type_traits/has_trivial_assign.hpp

@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
@@ -23,7 +25,7 @@
 
 namespace boost {
 
-   template <typename T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
    struct has_trivial_assign : public integral_constant < bool,
 #ifdef BOOST_HAS_TRIVIAL_ASSIGN
       BOOST_HAS_TRIVIAL_ASSIGN(T)
@@ -32,20 +34,20 @@ namespace boost {
 #endif
    > {};
 
-   template<> struct has_trivial_assign<void> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-   template<> struct has_trivial_assign<void const> : public false_type{};
-   template<> struct has_trivial_assign<void const volatile> : public false_type{};
-   template<> struct has_trivial_assign<void volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void const> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void const volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct has_trivial_assign<void volatile> : public false_type{};
 #endif
-   template <class T> struct has_trivial_assign<T volatile> : public false_type{};
-   template <class T> struct has_trivial_assign<T&> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_assign<T volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_assign<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-   template <class T> struct has_trivial_assign<T&&> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_assign<T&&> : public false_type{};
 #endif
    // Arrays are not explictly assignable:
-   template <typename T, std::size_t N> struct has_trivial_assign<T[N]> : public false_type{};
-   template <typename T> struct has_trivial_assign<T[]> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct has_trivial_assign<T[N]> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_assign<T[]> : public false_type{};
 
 } // namespace boost
 

include/boost/type_traits/has_trivial_constructor.hpp

@@ -36,19 +36,19 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_constructor
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_constructor
 #ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR
    : public integral_constant <bool, ((::boost::is_pod<T>::value || BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)) BOOST_TT_TRIVIAL_CONSTRUCT_FIX)>{};
 #else
    : public integral_constant <bool, ::boost::is_pod<T>::value>{};
 #endif
 
-template <> struct has_trivial_constructor<void> : public boost::false_type{};
-template <> struct has_trivial_constructor<void const> : public boost::false_type{};
-template <> struct has_trivial_constructor<void const volatile> : public boost::false_type{};
-template <> struct has_trivial_constructor<void volatile> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void const> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void const volatile> : public boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_constructor<void volatile> : public boost::false_type{};
 
-template <class T> struct has_trivial_default_constructor : public has_trivial_constructor<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_default_constructor : public has_trivial_constructor<T> {};
 
 #undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX
 

include/boost/type_traits/has_trivial_copy.hpp

@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/is_pod.hpp>
 #include <boost/type_traits/is_reference.hpp>
@@ -28,7 +30,7 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_copy 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_copy 
 : public integral_constant<bool, 
 #ifdef BOOST_HAS_TRIVIAL_COPY
    BOOST_HAS_TRIVIAL_COPY(T) BOOST_TT_TRIVIAL_CONSTRUCT_FIX
@@ -37,24 +39,24 @@ template <typename T> struct has_trivial_copy
 #endif
 >{};
 // Arrays are not explicitly copyable:
-template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
-template <typename T> struct has_trivial_copy<T[]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_copy<T[]> : public false_type{};
 // Are volatile types ever trivial?  We don't really know, so assume not:
-template <typename T> struct has_trivial_copy<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_copy<T volatile> : public false_type{};
 
-template <> struct has_trivial_copy<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_copy<void const> : public false_type{};
-template <> struct has_trivial_copy<void volatile> : public false_type{};
-template <> struct has_trivial_copy<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_copy<void const volatile> : public false_type{};
 #endif
 
-template <class T> struct has_trivial_copy<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_copy<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-template <class T> struct has_trivial_copy<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_copy<T&&> : public false_type{};
 #endif
 
-template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};
 
 #undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX
 

include/boost/type_traits/has_trivial_destructor.hpp

@@ -27,20 +27,20 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_destructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_DESTRUCTOR(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_destructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_DESTRUCTOR(T)>{};
 #else
 #include <boost/type_traits/is_pod.hpp>
 
 namespace boost{
 
-template <typename T> struct has_trivial_destructor : public integral_constant<bool, ::boost::is_pod<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_destructor : public integral_constant<bool, ::boost::is_pod<T>::value>{};
 #endif
 
-template <> struct has_trivial_destructor<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_destructor<void const> : public false_type{};
-template <> struct has_trivial_destructor<void const volatile> : public false_type{};
-template <> struct has_trivial_destructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_destructor<void volatile> : public false_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/has_trivial_move_assign.hpp

@@ -11,7 +11,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
@@ -43,7 +45,7 @@
 
 namespace boost{
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct has_trivial_move_assign : public integral_constant<bool,
 #ifdef BOOST_HAS_TRIVIAL_MOVE_ASSIGN
    BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T)
@@ -52,19 +54,19 @@ struct has_trivial_move_assign : public integral_constant<bool,
 #endif
    > {};
 
-template <> struct has_trivial_move_assign<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_move_assign<void const> : public false_type{};
-template <> struct has_trivial_move_assign<void const volatile> : public false_type{};
-template <> struct has_trivial_move_assign<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_assign<void volatile> : public false_type{};
 #endif
-template <class T> struct has_trivial_move_assign<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_assign<T&> : public false_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct has_trivial_move_assign<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_assign<T&&> : public false_type{};
 #endif
 // Array types are not assignable:
-template <class T, std::size_t N> struct has_trivial_move_assign<T[N]> : public false_type{};
-template <class T> struct has_trivial_move_assign<T[]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_trivial_move_assign<T[N]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_assign<T[]> : public false_type{};
 
 } // namespace boost
 

include/boost/type_traits/has_trivial_move_constructor.hpp

@@ -11,7 +11,9 @@
 #ifndef BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
 #define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
@@ -31,7 +33,7 @@
 
 namespace boost {
 
-template <typename T> struct has_trivial_move_constructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_move_constructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)>{};
 
 #else
 
@@ -52,27 +54,27 @@ template <typename T> struct has_trivial_move_constructor : public integral_cons
 
 namespace boost {
 
-template <typename T> struct has_trivial_move_constructor 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct has_trivial_move_constructor 
    : public integral_constant<bool, ::boost::is_pod<T>::value && !::boost::is_volatile<T>::value SOLARIS_EXTRA_CHECK>{};
 
 #undef SOLARIS_EXTRA_CHECK
 
 #endif
 
-template <> struct has_trivial_move_constructor<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct has_trivial_move_constructor<void const> : public false_type{};
-template <> struct has_trivial_move_constructor<void volatile> : public false_type{};
-template <> struct has_trivial_move_constructor<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct has_trivial_move_constructor<void const volatile> : public false_type{};
 #endif
 // What should we do with reference types??? The standard seems to suggest these are trivial, even if the thing they reference is not:
-template <class T> struct has_trivial_move_constructor<T&> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_constructor<T&> : public true_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct has_trivial_move_constructor<T&&> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_constructor<T&&> : public true_type{};
 #endif
 // Arrays can not be explicitly copied:
-template <class T, std::size_t N> struct has_trivial_move_constructor<T[N]> : public false_type{};
-template <class T> struct has_trivial_move_constructor<T[]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct has_trivial_move_constructor<T[N]> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_trivial_move_constructor<T[]> : public false_type{};
 
 } // namespace boost
 

include/boost/type_traits/has_virtual_destructor.hpp

@@ -16,9 +16,9 @@
 namespace boost {
 
 #ifdef BOOST_HAS_VIRTUAL_DESTRUCTOR
-   template <class T> struct has_virtual_destructor : public integral_constant<bool, BOOST_HAS_VIRTUAL_DESTRUCTOR(T)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_virtual_destructor : public integral_constant<bool, BOOST_HAS_VIRTUAL_DESTRUCTOR(T)>{};
 #else
-   template <class T> struct has_virtual_destructor : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct has_virtual_destructor : public integral_constant<bool, false>{};
 #endif
 
 } // namespace boost

include/boost/type_traits/integral_constant.hpp

@@ -6,8 +6,7 @@
 #ifndef BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
 #define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) \
@@ -20,9 +19,9 @@
 namespace boost{
    namespace mpl
    {
-      template <bool B> struct bool_;
-      template <class I, I val> struct integral_c;
-      struct integral_c_tag;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool B> struct bool_;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT template <class I, I val> struct integral_c;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT struct integral_c_tag;
    }
 }
 
@@ -30,18 +29,18 @@ namespace boost{
 
 namespace mpl_{
 
-   template <bool B> struct bool_;
-   template <class I, I val> struct integral_c;
-   struct integral_c_tag;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool B> struct bool_;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class I, I val> struct integral_c;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT struct integral_c_tag;
 }
 
 namespace boost
 {
    namespace mpl
    {
-      using ::mpl_::bool_;
-      using ::mpl_::integral_c;
-      using ::mpl_::integral_c_tag;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT using ::mpl_::bool_;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT using ::mpl_::integral_c;
+      BOOST_TYPE_TRAITS_MODULE_EXPORT using ::mpl_::integral_c_tag;
    }
 }
 
@@ -49,7 +48,7 @@ namespace boost
 
 namespace boost{
 
-   template <class T, T val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, T val>
    struct integral_constant
    {
       typedef mpl::integral_c_tag tag;
@@ -66,10 +65,10 @@ namespace boost{
       BOOST_CONSTEXPR operator T()const { return val; }
    };
 
-   template <class T, T val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, T val>
    T const integral_constant<T, val>::value;
       
-   template <bool val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool val>
    struct integral_constant<bool, val>
    {
       typedef mpl::integral_c_tag tag;
@@ -86,11 +85,11 @@ namespace boost{
       BOOST_CONSTEXPR operator bool()const { return val; }
    };
 
-   template <bool val>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <bool val>
    bool const integral_constant<bool, val>::value;
 
-   typedef integral_constant<bool, true> true_type;
-   typedef integral_constant<bool, false> false_type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT typedef integral_constant<bool, true> true_type;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT typedef integral_constant<bool, false> false_type;
 
 }
 

include/boost/type_traits/integral_promotion.hpp

@@ -6,7 +6,7 @@
 #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
 #define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_enum.hpp>

include/boost/type_traits/intrinsics.hpp

@@ -10,8 +10,6 @@
 
 #ifndef BOOST_TT_DISABLE_INTRINSICS
 
-#include <boost/config.hpp>
-
 #ifndef BOOST_TT_CONFIG_HPP_INCLUDED
 #include <boost/type_traits/detail/config.hpp>
 #endif
@@ -172,7 +170,9 @@
 // we do not #include those here as it produces cyclic dependencies and
 // can cause the intrinsics to not even be used at all!
 //
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #   include <cstddef>
+#endif
 
 #   if __has_feature(is_union)
 #     define BOOST_IS_UNION(T) __is_union(T)

include/boost/type_traits/is_abstract.hpp

@@ -47,12 +47,17 @@
 //  - Dec 2004: Added new config macro BOOST_NO_IS_ABSTRACT which causes the template
 //              to degrade gracefully, rather than trash the compiler (John Maddock).
 //
-
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
+
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #ifndef BOOST_IS_ABSTRACT
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/is_class.hpp>
 #ifdef BOOST_NO_IS_ABSTRACT
@@ -140,9 +145,9 @@ struct is_abstract_imp
 }
 
 #ifndef BOOST_NO_IS_ABSTRACT
-template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};
 #else
-template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_arithmetic.hpp

@@ -14,7 +14,7 @@
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};
 
 } // namespace boost

include/boost/type_traits/is_array.hpp

@@ -15,24 +15,26 @@
 #define BOOST_TT_IS_ARRAY_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T> struct is_array : public integral_constant<bool, __is_array(T)> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array : public integral_constant<bool, __is_array(T)> {};
 #else
-   template <class T> struct is_array : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array : public false_type {};
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-   template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
-   template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
-   template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
-   template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
-   template <class T> struct is_array<T[]> : public true_type{};
-   template <class T> struct is_array<T const[]> : public true_type{};
-   template <class T> struct is_array<T const volatile[]> : public true_type{};
-   template <class T> struct is_array<T volatile[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T const[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T const volatile[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_array<T volatile[]> : public true_type{};
 #endif
 #endif
 

include/boost/type_traits/is_assignable.hpp

@@ -9,15 +9,17 @@
 #ifndef BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED
 #define BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_complete.hpp>
 #include <boost/static_assert.hpp>
+#endif
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#include <boost/type_traits/is_complete.hpp>
 
 namespace boost{
 
-   template <class T, class U = T> struct is_assignable;
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U = T> struct is_assignable;
 
 }
 
@@ -41,18 +43,18 @@ namespace boost{
 
    }
 
-   template <class T, class U> struct is_assignable : public integral_constant<bool, sizeof(detail::is_assignable_imp::test<T, U>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_assignable : public integral_constant<bool, sizeof(detail::is_assignable_imp::test<T, U>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_assignable must be complete types");
    };
-   template <class T, std::size_t N, class U> struct is_assignable<T[N], U> : public is_assignable<T, U>{};
-   template <class T, std::size_t N, class U> struct is_assignable<T(&)[N], U> : public is_assignable<T&, U>{};
-   template <class T, class U> struct is_assignable<T[], U> : public is_assignable<T, U>{};
-   template <class T, class U> struct is_assignable<T(&)[], U> : public is_assignable<T&, U>{};
-   template <class U> struct is_assignable<void, U> : public integral_constant<bool, false>{};
-   template <class U> struct is_assignable<void const, U> : public integral_constant<bool, false>{};
-   template <class U> struct is_assignable<void volatile, U> : public integral_constant<bool, false>{};
-   template <class U> struct is_assignable<void const volatile, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N, class U> struct is_assignable<T[N], U> : public is_assignable<T, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N, class U> struct is_assignable<T(&)[N], U> : public is_assignable<T&, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_assignable<T[], U> : public is_assignable<T, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_assignable<T(&)[], U> : public is_assignable<T&, U>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void const, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void volatile, U> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class U> struct is_assignable<void const volatile, U> : public integral_constant<bool, false>{};
 
 #else
 

include/boost/type_traits/is_base_and_derived.hpp

@@ -15,9 +15,11 @@
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
 #endif
+#endif
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/is_same.hpp>
 
@@ -228,15 +230,15 @@ struct is_base_and_derived_impl
 #endif
 } // namespace detail
 
-template <class Base, class Derived> struct is_base_and_derived
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived
    : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};
 
-template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
-template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
-template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
 
 #if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x610))
-template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_base_of.hpp

@@ -27,12 +27,12 @@ namespace boost {
       };
    }
 
-   template <class Base, class Derived> struct is_base_of
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of
       : public integral_constant<bool, (::boost::detail::is_base_of_imp<Base, Derived>::value)> {};
 
-   template <class Base, class Derived> struct is_base_of<Base, Derived&> : false_type{};
-   template <class Base, class Derived> struct is_base_of<Base&, Derived&> : false_type{};
-   template <class Base, class Derived> struct is_base_of<Base&, Derived> : false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of<Base, Derived&> : false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of<Base&, Derived&> : false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Base, class Derived> struct is_base_of<Base&, Derived> : false_type{};
 
 } // namespace boost
 

include/boost/type_traits/is_bounded_array.hpp

@@ -11,28 +11,30 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 #define BOOST_TT_IS_BOUNDED_ARRAY_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef>
+#endif
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_bounded_array
     : false_type { };
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<T[N]>
     : true_type { };
 
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<const T[N]>
     : true_type { };
 
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<volatile T[N]>
     : true_type { };
 
-template<class T, std::size_t N>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, std::size_t N>
 struct is_bounded_array<const volatile T[N]>
     : true_type { };
 #endif

include/boost/type_traits/is_class.hpp

@@ -102,11 +102,11 @@ struct is_class_impl
 
 } // namespace detail
 
-template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
 # ifdef __EDG_VERSION__
-template <class T> struct is_class<const T> : public is_class<T>{};
-template <class T> struct is_class<const volatile T> : public is_class<T>{};
-template <class T> struct is_class<volatile T> : public is_class<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class<const T> : public is_class<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class<const volatile T> : public is_class<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_class<volatile T> : public is_class<T>{};
 # endif
     
 } // namespace boost

include/boost/type_traits/is_complete.hpp

@@ -14,8 +14,9 @@
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_function.hpp>
 #include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/config/workaround.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef>
+#endif
 
 /*
  * CAUTION:
@@ -50,7 +51,7 @@ namespace boost {
       char check_is_complete(...);
    }
 
-   template <class T> struct is_complete
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complete
       : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {};
 
 #elif !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
@@ -73,16 +74,16 @@ namespace boost {
 } // namespace detail
 
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_complete : boost::integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || ::boost::detail::is_complete_imp<T>::value>
    {};
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_complete<T&> : boost::is_complete<T> {};
    
 #else
 
-      template <class T> struct is_complete
-         : public boost::integral_constant<bool, true> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complete
+      : public boost::integral_constant<bool, true> {};
 
 #undef BOOST_TT_HAS_WORKING_IS_COMPLETE
 

include/boost/type_traits/is_complex.hpp

@@ -8,17 +8,19 @@
 #ifndef BOOST_TT_IS_COMPLEX_HPP
 #define BOOST_TT_IS_COMPLEX_HPP
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
 #include <complex>
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
-   template <class T> struct is_complex : public false_type {};
-   template <class T> struct is_complex<const T > : public is_complex<T>{};
-   template <class T> struct is_complex<volatile const T > : public is_complex<T>{};
-   template <class T> struct is_complex<volatile T > : public is_complex<T>{};
-   template <class T> struct is_complex<std::complex<T> > : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<const T > : public is_complex<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<volatile const T > : public is_complex<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<volatile T > : public is_complex<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_complex<std::complex<T> > : public true_type{};
 
 } // namespace boost
 

include/boost/type_traits/is_compound.hpp

@@ -14,9 +14,9 @@
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T> struct is_compound : public integral_constant<bool, __is_compound(T)> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_compound : public integral_constant<bool, __is_compound(T)> {};
 #else
-   template <class T> struct is_compound : public integral_constant<bool, ! ::boost::is_fundamental<T>::value> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_compound : public integral_constant<bool, ! ::boost::is_fundamental<T>::value> {};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_const.hpp

@@ -21,23 +21,25 @@
 #ifndef BOOST_TT_IS_CONST_HPP_INCLUDED
 #define BOOST_TT_IS_CONST_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_const : public integral_constant<bool, __is_const(T)> {};
 
 #else
 
-   template <class T>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
    struct is_const : public false_type {};
-   template <class T> struct is_const<T const> : public true_type{};
-   template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
-   template <class T> struct is_const<T const[]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_const<T const> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_const<T const[]> : public true_type{};
 
 #endif
 

include/boost/type_traits/is_constructible.hpp

@@ -10,7 +10,12 @@
 #define BOOST_TT_IS_CONSTRUCTIBLE_HPP_INCLUDED
 
 #include <boost/type_traits/integral_constant.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
 
@@ -19,7 +24,6 @@
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/static_assert.hpp>
 
 #define BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING 1
 
@@ -47,23 +51,23 @@ namespace boost{
 
    }
 
-   template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
    };
-   template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
    };
-   template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
-   template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
 
-   template <> struct is_constructible<void> : public false_type{};
-   template <> struct is_constructible<void const> : public false_type{};
-   template <> struct is_constructible<void const volatile> : public false_type{};
-   template <> struct is_constructible<void volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void const> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void const volatile> : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_constructible<void volatile> : public false_type{};
 
-   template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
 
 #else
 

include/boost/type_traits/is_convertible.hpp

@@ -17,11 +17,9 @@
 #include <boost/type_traits/is_complete.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_array.hpp>
-#include <boost/static_assert.hpp>
 #ifndef BOOST_IS_CONVERTIBLE
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/detail/config.hpp>
-#include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_void.hpp>
 #if !defined(BOOST_NO_IS_ABSTRACT)
@@ -42,6 +40,10 @@
 #include <boost/type_traits/is_same.hpp>
 #endif // BOOST_IS_CONVERTIBLE
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
+#include <boost/static_assert.hpp>
+#endif
+
 namespace boost {
 
 #ifndef BOOST_IS_CONVERTIBLE
@@ -477,7 +479,7 @@ template <class From> struct is_convertible_impl_dispatch<From, void volatile> :
 
 } // namespace detail
 
-template <class From, class To> 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class From, class To>
 struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value> 
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<To>::value || boost::is_void<To>::value || boost::is_array<To>::value, "Destination argument type to is_convertible must be a complete type");
@@ -486,7 +488,7 @@ struct is_convertible : public integral_constant<bool, ::boost::detail::is_conve
 
 #else
 
-template <class From, class To>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class From, class To>
 struct is_convertible : public integral_constant<bool, BOOST_IS_CONVERTIBLE(From, To)> 
 {
 #if defined(BOOST_MSVC)

include/boost/type_traits/is_copy_assignable.hpp

@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
 #define BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/config.hpp>
+#endif
 #include <boost/type_traits/detail/yes_no_type.hpp>
 #include <boost/type_traits/is_noncopyable.hpp>
 
@@ -127,12 +129,12 @@ struct is_copy_assignable_impl {
 
 } // namespace detail
 
-template <class T> struct is_copy_assignable : public integral_constant<bool, ::boost::detail::is_copy_assignable_impl<T>::value>{};
-template <> struct is_copy_assignable<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_copy_assignable : public integral_constant<bool, ::boost::detail::is_copy_assignable_impl<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_copy_assignable<void const> : public false_type{};
-template <> struct is_copy_assignable<void const volatile> : public false_type{};
-template <> struct is_copy_assignable<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_assignable<void volatile> : public false_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_copy_constructible.hpp

@@ -9,8 +9,7 @@
 #ifndef BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40900)
 
@@ -20,12 +19,12 @@
 
 namespace boost {
 
-template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};
 
-template <> struct is_copy_constructible<void> : public false_type{};
-template <> struct is_copy_constructible<void const> : public false_type{};
-template <> struct is_copy_constructible<void const volatile> : public false_type{};
-template <> struct is_copy_constructible<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_copy_constructible<void volatile> : public false_type{};
 
 } // namespace boost
 

include/boost/type_traits/is_default_constructible.hpp

@@ -9,18 +9,22 @@
 #ifndef BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_complete.hpp>
 #include <boost/static_assert.hpp>
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5)) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1800))
+#include <utility> // std::pair
+#endif
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_complete.hpp>
 
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
 #include <boost/type_traits/is_abstract.hpp>
 #endif
-#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5)) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1800))
-#include <utility> // std::pair
-#endif
 
 #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
 
@@ -58,24 +62,24 @@ namespace boost{
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
    };
 #else
-   template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
    };
 #endif
-   template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
-   template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
-   template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};
 #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5))|| (defined(BOOST_MSVC) && (BOOST_MSVC == 1800))
-   template <class T, class U> struct is_default_constructible<std::pair<T,U> > : public integral_constant<bool, is_default_constructible<T>::value && is_default_constructible<U>::value>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_default_constructible<std::pair<T,U> > : public integral_constant<bool, is_default_constructible<T>::value && is_default_constructible<U>::value>{};
 #endif
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-   template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};
 #endif
-   template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
-   template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
-   template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
-   template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
 
 #else
 

include/boost/type_traits/is_destructible.hpp

@@ -9,11 +9,16 @@
 #ifndef BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_complete.hpp>
 #include <boost/static_assert.hpp>
+#else
+#include <boost/type_traits/detail/config.hpp>
+#endif
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_complete.hpp>
 
 #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
 
@@ -34,7 +39,7 @@ namespace boost{
 
    }
 
-   template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
    {
       BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_destructible must be complete types");
    };

include/boost/type_traits/is_detected.hpp

@@ -15,12 +15,12 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<template<class...> class Op, class... Args>
 using is_detected = typename
     detail::detector<nonesuch, void, Op, Args...>::value_t;
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
-template<template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<template<class...> class Op, class... Args>
 constexpr bool is_detected_v = is_detected<Op, Args...>::value;
 #endif
 

include/boost/type_traits/is_detected_convertible.hpp

@@ -15,11 +15,11 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class To, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class To, template<class...> class Op, class... Args>
 using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
-template<class To, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class To, template<class...> class Op, class... Args>
 constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op,
     Args...>::value;
 #endif

include/boost/type_traits/is_detected_exact.hpp

@@ -15,11 +15,11 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class Expected, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Expected, template<class...> class Op, class... Args>
 using is_detected_exact = is_same<Expected, detected_t<Op, Args...> >;
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
-template<class Expected, template<class...> class Op, class... Args>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class Expected, template<class...> class Op, class... Args>
 constexpr bool is_detected_exact_v = is_detected_exact<Expected, Op,
     Args...>::value;
 #endif

include/boost/type_traits/is_empty.hpp

@@ -110,7 +110,7 @@ struct is_empty_impl
 
 } // namespace detail
 
-template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> {};
 
 } // namespace boost
 

include/boost/type_traits/is_enum.hpp

@@ -145,19 +145,19 @@ template <typename T> struct is_enum_impl
 
 } // namespace detail
 
-template <class T> struct is_enum : public integral_constant<bool, ::boost::detail::is_enum_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_enum : public integral_constant<bool, ::boost::detail::is_enum_impl<T>::value> {};
 
 #else // BOOST_BORLANDC
 //
 // buggy is_convertible prevents working
 // implementation of is_enum:
-template <class T> struct is_enum : public integral_constant<bool, false> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_enum : public integral_constant<bool, false> {};
 
 #endif
 
 #else // BOOST_IS_ENUM
 
-template <class T> struct is_enum : public integral_constant<bool, BOOST_IS_ENUM(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_enum : public integral_constant<bool, BOOST_IS_ENUM(T)> {};
 
 #endif
 

include/boost/type_traits/is_final.hpp

@@ -20,9 +20,9 @@
 namespace boost {
 
 #ifdef BOOST_IS_FINAL
-template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_final : public integral_constant<bool, BOOST_IS_FINAL(T)> {};
 #else
-template <class T> struct is_final : public integral_constant<bool, false> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_final : public integral_constant<bool, false> {};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_float.hpp

@@ -14,7 +14,7 @@
 namespace boost {
 
 //* is a type T a floating-point type described in the standard (3.9.1p8)
-   template <class T> struct is_float : public is_floating_point<T> {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_float : public is_floating_point<T> {};
 } // namespace boost
 
 #endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED

include/boost/type_traits/is_floating_point.hpp

@@ -13,16 +13,16 @@
 namespace boost {
 
 //* is a type T a floating-point type described in the standard (3.9.1p8)
-   template <class T> struct is_floating_point : public false_type{};
-   template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
-   template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
-   template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
-   template<> struct is_floating_point<float> : public true_type{};
-   template<> struct is_floating_point<double> : public true_type{};
-   template<> struct is_floating_point<long double> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<float> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<double> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<long double> : public true_type{};
    
 #if defined(BOOST_HAS_FLOAT128)
-   template<> struct is_floating_point<__float128> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_floating_point<__float128> : public true_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_function.hpp

@@ -12,7 +12,6 @@
 #define BOOST_TT_IS_FUNCTION_HPP_INCLUDED
 
 #include <boost/type_traits/detail/config.hpp>
-#include <boost/config/workaround.hpp>
 
 #ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION
 

include/boost/type_traits/is_fundamental.hpp

@@ -16,9 +16,9 @@ namespace boost {
 
 //* is a type T a fundamental type described in the standard (3.9.1)
 #if defined( BOOST_CODEGEARC )
-template <class T> struct is_fundamental : public integral_constant<bool, __is_fundamental(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_fundamental : public integral_constant<bool, __is_fundamental(T)> {};
 #else
-template <class T> struct is_fundamental : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_void<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_fundamental : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_void<T>::value> {};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_integral.hpp

@@ -9,77 +9,77 @@
 #ifndef BOOST_TT_IS_INTEGRAL_HPP_INCLUDED
 #define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T>
-   struct is_integral : public integral_constant<bool, __is_integral(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
+struct is_integral : public integral_constant<bool, __is_integral(T)> {};
 #else
 
-template <class T> struct is_integral : public false_type {};
-template <class T> struct is_integral<const T> : public is_integral<T> {};
-template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
-template <class T> struct is_integral<volatile T> : public is_integral<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral : public false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral<const T> : public is_integral<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_integral<volatile T> : public is_integral<T>{};
 
 //* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3)
 // as an extension we include long long, as this is likely to be added to the
 // standard at a later date
-template<> struct is_integral<unsigned char> : public true_type {};
-template<> struct is_integral<unsigned short> : public true_type{};
-template<> struct is_integral<unsigned int> : public true_type{};
-template<> struct is_integral<unsigned long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned char> : public true_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned long> : public true_type{};
 
-template<> struct is_integral<signed char> : public true_type{};
-template<> struct is_integral<short> : public true_type{};
-template<> struct is_integral<int> : public true_type{};
-template<> struct is_integral<long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<long> : public true_type{};
 
-template<> struct is_integral<char> : public true_type{};
-template<> struct is_integral<bool> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<bool> : public true_type{};
 
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 // If the following line fails to compile and you're using the Intel
 // compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php,
 // and define BOOST_NO_INTRINSIC_WCHAR_T on the command line.
-template<> struct is_integral<wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<wchar_t> : public true_type{};
 #endif
 
 // Same set of integral types as in boost/type_traits/integral_promotion.hpp.
 // Please, keep in sync. -- Alexander Nasonov
 #if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
     || (defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x600) && (_MSC_VER < 1300))
-template<> struct is_integral<unsigned __int8> : public true_type{};
-template<> struct is_integral<unsigned __int16> : public true_type{};
-template<> struct is_integral<unsigned __int32> : public true_type{};
-template<> struct is_integral<__int8> : public true_type{};
-template<> struct is_integral<__int16> : public true_type{};
-template<> struct is_integral<__int32> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int8> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int16> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int32> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int8> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int16> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int32> : public true_type{};
 #ifdef BOOST_BORLANDC
-template<> struct is_integral<unsigned __int64> : public true_type{};
-template<> struct is_integral<__int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int64> : public true_type{};
 #endif
 #endif
 
-# if defined(BOOST_HAS_LONG_LONG)
-template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
-template<> struct is_integral< ::boost::long_long_type> : public true_type{};
+# if !defined(BOOST_NO_LONG_LONG)
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral< ::boost::long_long_type> : public true_type{};
 #elif defined(BOOST_HAS_MS_INT64)
-template<> struct is_integral<unsigned __int64> : public true_type{};
-template<> struct is_integral<__int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<unsigned __int64> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<__int64> : public true_type{};
 #endif
         
 #ifdef BOOST_HAS_INT128
-template<> struct is_integral<boost::int128_type> : public true_type{};
-template<> struct is_integral<boost::uint128_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<boost::int128_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<boost::uint128_type> : public true_type{};
 #endif
 #ifndef BOOST_NO_CXX11_CHAR16_T
-template<> struct is_integral<char16_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<char16_t> : public true_type{};
 #endif
 #ifndef BOOST_NO_CXX11_CHAR32_T
-template<> struct is_integral<char32_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_integral<char32_t> : public true_type{};
 #endif
 
 #endif  // non-CodeGear implementation

include/boost/type_traits/is_list_constructible.hpp

@@ -7,12 +7,13 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost
 {
@@ -21,7 +22,7 @@ namespace boost
    || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)\
    || BOOST_WORKAROUND(BOOST_GCC, < 40700)
 
-template<class T, class = void, class = void, class = void, class = void, class = void, class = void> struct is_list_constructible: false_type
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class = void, class = void, class = void, class = void, class = void, class = void> struct is_list_constructible: false_type
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_list_constructible must be complete types");
 };
@@ -36,7 +37,7 @@ template<class T, class... A> false_type is_list_constructible_impl( ... );
 
 } // namespace type_traits_detail
 
-template<class T, class... A> struct is_list_constructible: decltype( type_traits_detail::is_list_constructible_impl<T, A...>(0) )
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T, class... A> struct is_list_constructible: decltype( type_traits_detail::is_list_constructible_impl<T, A...>(0) )
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_list_constructible must be complete types");
 };

include/boost/type_traits/is_lvalue_reference.hpp

@@ -26,11 +26,11 @@
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-   template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{};
 #else
 
-   template <class T> struct is_lvalue_reference : public false_type{};
-   template <class T> struct is_lvalue_reference<T&> : public true_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_lvalue_reference : public false_type{};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_lvalue_reference<T&> : public true_type{};
 
 #if  defined(BOOST_ILLEGAL_CV_REFERENCES)
 // these are illegal specialisations; cv-qualifies applied to

include/boost/type_traits/is_member_object_pointer.hpp

@@ -15,7 +15,7 @@
 
 namespace boost {
 
-template <class T> struct is_member_object_pointer 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_member_object_pointer 
    : public integral_constant<bool, 
    ::boost::is_member_pointer<T>::value && !::boost::is_member_function_pointer<T>::value>{};
 

include/boost/type_traits/is_member_pointer.hpp

@@ -21,21 +21,21 @@
 #ifndef BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED
 #define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED
 
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 
 namespace boost {
 
 #if defined( BOOST_CODEGEARC )
-template <class T> struct is_member_pointer : public integral_constant<bool, __is_member_pointer(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_member_pointer : public integral_constant<bool, __is_member_pointer(T)>{};
 #else
-template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
-template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};
 
 #if !BOOST_WORKAROUND(__MWERKS__,<=0x3003) && !BOOST_WORKAROUND(__IBMCPP__, <=600)
-template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
-template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
-template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};
 #endif
 
 #endif

include/boost/type_traits/is_noncopyable.hpp

@@ -30,7 +30,7 @@ namespace noncopyable_
 
 #endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
 
-template<class T> struct is_noncopyable: is_base_and_derived<noncopyable_::base_token, T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct is_noncopyable: is_base_and_derived<noncopyable_::base_token, T>
 {
 };
 

include/boost/type_traits/is_nothrow_move_assignable.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED
 #define BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/has_trivial_move_assign.hpp>
 #include <boost/type_traits/has_nothrow_assign.hpp>
 #include <boost/type_traits/is_array.hpp>
@@ -19,23 +19,25 @@
 #include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/static_assert.hpp>
+#endif
 
 namespace boost {
 
 #ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_assignable : public integral_constant<bool, BOOST_IS_NOTHROW_MOVE_ASSIGN(T)>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_assignable must be complete types");
 };
-template <class T> struct is_nothrow_move_assignable<T const> : public false_type{};
-template <class T> struct is_nothrow_move_assignable<T volatile> : public false_type{};
-template <class T> struct is_nothrow_move_assignable<T const volatile> : public false_type{};
-template <class T> struct is_nothrow_move_assignable<T&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&> : public false_type{};
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
-template <class T> struct is_nothrow_move_assignable<T&&> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&&> : public false_type{};
 #endif
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
@@ -54,23 +56,23 @@ struct false_or_cpp11_noexcept_move_assignable <
 
 }
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_assignable : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_assignable must be complete types");
 };
 
-template <class T> struct is_nothrow_move_assignable<T const> : public ::boost::false_type {};
-template <class T> struct is_nothrow_move_assignable<T const volatile> : public ::boost::false_type{};
-template <class T> struct is_nothrow_move_assignable<T volatile> : public ::boost::false_type{};
-template <class T> struct is_nothrow_move_assignable<T&> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const> : public ::boost::false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T const volatile> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T volatile> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&> : public ::boost::false_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_nothrow_move_assignable<T&&> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_assignable<T&&> : public ::boost::false_type{};
 #endif
 
 #else
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_assignable : public integral_constant<bool,
    (::boost::has_trivial_move_assign<T>::value || ::boost::has_nothrow_assign<T>::value) &&  ! ::boost::is_array<T>::value>
 {
@@ -80,11 +82,11 @@ struct is_nothrow_move_assignable : public integral_constant<bool,
 #endif
 
 
-template <> struct is_nothrow_move_assignable<void> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void> : public false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_nothrow_move_assignable<void const> : public false_type{};
-template <> struct is_nothrow_move_assignable<void const volatile> : public false_type{};
-template <> struct is_nothrow_move_assignable<void volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void const> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void const volatile> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_assignable<void volatile> : public false_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_nothrow_move_constructible.hpp

@@ -11,26 +11,27 @@
 #ifndef BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
 #define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
-#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#endif
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/intrinsics.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/static_assert.hpp>
 
 #ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT
 
 namespace boost {
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_constructible : public integral_constant<bool, BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T)>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
 };
 
-template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
-template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
 
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
 
@@ -51,16 +52,16 @@ struct false_or_cpp11_noexcept_move_constructible <
 
 }
 
-template <class T> struct is_nothrow_move_constructible
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible
    : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value>
 {
    BOOST_STATIC_ASSERT_MSG(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
 };
 
-template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
-template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
-template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
-template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
 
 #else
 
@@ -70,7 +71,7 @@ template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::f
 
 namespace boost{
 
-template <class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T>
 struct is_nothrow_move_constructible
    : public integral_constant<bool,
    (::boost::has_trivial_move_constructor<T>::value || ::boost::has_nothrow_copy<T>::value) && !::boost::is_array<T>::value>
@@ -80,16 +81,16 @@ struct is_nothrow_move_constructible
 
 #endif
 
-template <> struct is_nothrow_move_constructible<void> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void> : false_type{};
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template <> struct is_nothrow_move_constructible<void const> : false_type{};
-template <> struct is_nothrow_move_constructible<void volatile> : false_type{};
-template <> struct is_nothrow_move_constructible<void const volatile> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void const> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void volatile> : false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_nothrow_move_constructible<void const volatile> : false_type{};
 #endif
 // References are always trivially constructible, even if the thing they reference is not:
-template <class T> struct is_nothrow_move_constructible<T&> : public ::boost::true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<T&> : public ::boost::true_type{};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_nothrow_move_constructible<T&&> : public ::boost::true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_move_constructible<T&&> : public ::boost::true_type{};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_nothrow_swappable.hpp

@@ -7,8 +7,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 #if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DECLTYPE) \
    || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
@@ -19,18 +18,21 @@
 
 namespace boost
 {
-template <class T> struct is_nothrow_swappable : boost::integral_constant<bool,
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_swappable : boost::integral_constant<bool,
     boost::is_scalar<T>::value && !boost::is_const<T>::value> {};
 
-template <class T, class U> struct is_nothrow_swappable_with : false_type {};
-template <class T> struct is_nothrow_swappable_with<T, T> : is_nothrow_swappable<T> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_nothrow_swappable_with : false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_nothrow_swappable_with<T, T> : is_nothrow_swappable<T> {};
 }
 
 #else
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
+#include <utility>
+#endif
+
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <algorithm>
 
 namespace boost
 {
@@ -56,7 +58,7 @@ template<class T, class U> struct is_nothrow_swappable_with: type_traits_swappab
 {
 };
 
-template<class T> struct is_nothrow_swappable: type_traits_swappable_detail::is_nothrow_swappable_helper<T>::type
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct is_nothrow_swappable: type_traits_swappable_detail::is_nothrow_swappable_helper<T>::type
 {
 };
 

include/boost/type_traits/is_object.hpp

@@ -9,14 +9,14 @@
 #ifndef BOOST_TT_IS_OBJECT_HPP_INCLUDED
 #define BOOST_TT_IS_OBJECT_HPP_INCLUDED
 
-#include <boost/config.hpp>
+#include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_function.hpp>
 
 namespace boost {
 
-template <class T> struct is_object
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_object
    : public 
       integral_constant<
          bool, 

include/boost/type_traits/is_pod.hpp

@@ -9,7 +9,9 @@
 #ifndef BOOST_TT_IS_POD_HPP_INCLUDED
 #define BOOST_TT_IS_POD_HPP_INCLUDED
 
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <cstddef> // size_t
+#endif
 #include <boost/type_traits/detail/config.hpp>
 #include <boost/type_traits/is_void.hpp>
 #include <boost/type_traits/is_scalar.hpp>
@@ -19,8 +21,6 @@
 #include <boost/type_traits/is_function.hpp>
 #endif
 
-#include <cstddef>
-
 #ifndef BOOST_IS_POD
 #define BOOST_INTERNAL_IS_POD(T) false
 #else
@@ -30,27 +30,27 @@
 namespace boost {
 
 // forward declaration, needed by 'is_pod_array_helper' template below
-template< typename T > struct is_POD;
+BOOST_TYPE_TRAITS_MODULE_EXPORT template< typename T > struct is_POD;
 
-template <typename T> struct is_pod
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T> struct is_pod
 : public integral_constant<bool, ::boost::is_scalar<T>::value || ::boost::is_void<T>::value || BOOST_INTERNAL_IS_POD(T)>
 {};
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};
 #endif
 
 
 // the following help compilers without partial specialization support:
-template<> struct is_pod<void> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void> : public true_type{};
 
 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct is_pod<void const> : public true_type{};
-template<> struct is_pod<void const volatile> : public true_type{};
-template<> struct is_pod<void volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void const> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void const volatile> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<> struct is_pod<void volatile> : public true_type{};
 #endif
 
-template<class T> struct is_POD : public is_pod<T>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T> struct is_POD : public is_pod<T>{};
 
 } // namespace boost
 

include/boost/type_traits/is_polymorphic.hpp

@@ -13,7 +13,9 @@
 #ifndef BOOST_IS_POLYMORPHIC
 #include <boost/type_traits/is_class.hpp>
 #endif
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <boost/detail/workaround.hpp>
+#endif
 
 #if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700)
 #pragma warning(push)
@@ -105,11 +107,11 @@ struct is_polymorphic_imp
 
 } // namespace detail
 
-template <class T> struct is_polymorphic : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_polymorphic : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
 
 #else // BOOST_IS_POLYMORPHIC
 
-template <class T> struct is_polymorphic : public integral_constant<bool, BOOST_IS_POLYMORPHIC(T)> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_polymorphic : public integral_constant<bool, BOOST_IS_POLYMORPHIC(T)> {};
 
 #endif
 

include/boost/type_traits/is_reference.hpp

@@ -17,7 +17,7 @@
 
 namespace boost {
 
-template <class T> struct is_reference 
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_reference 
    : public 
    integral_constant<
       bool, 

include/boost/type_traits/is_rvalue_reference.hpp

@@ -9,14 +9,13 @@
 #ifndef BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
 #define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
 
-#include <boost/config.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
 namespace boost {
 
-template <class T> struct is_rvalue_reference : public false_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_rvalue_reference : public false_type {};
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <class T> struct is_rvalue_reference<T&&> : public true_type {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_rvalue_reference<T&&> : public true_type {};
 #endif
 
 } // namespace boost

include/boost/type_traits/is_same.hpp

@@ -26,8 +26,8 @@
 namespace boost {
 
 
-   template <class T, class U> struct is_same : public false_type {};
-   template <class T> struct is_same<T,T> : public true_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T, class U> struct is_same : public false_type {};
+   BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_same<T,T> : public true_type {};
 #if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600)
 // without this, Borland's compiler gives the wrong answer for
 // references to arrays:

include/boost/type_traits/is_scalar.hpp

@@ -13,11 +13,10 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_pointer.hpp>
-#include <boost/config.hpp>
 
 namespace boost {
 
-template <typename T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <typename T>
 struct is_scalar
    : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_enum<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value>
 {};

include/boost/type_traits/is_scoped_enum.hpp

@@ -17,7 +17,7 @@ or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 namespace boost {
 
-template<class T>
+BOOST_TYPE_TRAITS_MODULE_EXPORT template<class T>
 struct is_scoped_enum
     : conjunction<is_enum<T>, negation<is_convertible<T, int> > >::type { };
 

include/boost/type_traits/is_signed.hpp

@@ -13,7 +13,9 @@
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/is_enum.hpp>
+#ifndef BOOST_TYPE_TRAITS_AS_MODULE
 #include <climits>
+#endif
 
 namespace boost {
 
@@ -76,86 +78,86 @@ struct is_signed_impl
 
 }
 
-template <class T> struct is_signed : public integral_constant<bool, boost::detail::is_signed_impl<T>::value> {};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_signed : public integral_constant<bool, boost::detail::is_signed_impl<T>::value> {};
 
 #else
 
-template <class T> struct is_signed : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_signed : public false_type{};
 
 #endif
 
 #else //defined( BOOST_CODEGEARC )
-   template <class T> struct is_signed : public integral_constant<bool, __is_signed(T)>{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <class T> struct is_signed : public integral_constant<bool, __is_signed(T)>{};
 #endif
 
-template <> struct is_signed<signed char> : public true_type{};
-template <> struct is_signed<const signed char> : public true_type{};
-template <> struct is_signed<volatile signed char> : public true_type{};
-template <> struct is_signed<const volatile signed char> : public true_type{};
-template <> struct is_signed<short> : public true_type{};
-template <> struct is_signed<const short> : public true_type{};
-template <> struct is_signed<volatile short> : public true_type{};
-template <> struct is_signed<const volatile short> : public true_type{};
-template <> struct is_signed<int> : public true_type{};
-template <> struct is_signed<const int> : public true_type{};
-template <> struct is_signed<volatile int> : public true_type{};
-template <> struct is_signed<const volatile int> : public true_type{};
-template <> struct is_signed<long> : public true_type{};
-template <> struct is_signed<const long> : public true_type{};
-template <> struct is_signed<volatile long> : public true_type{};
-template <> struct is_signed<const volatile long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile signed char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile short> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile int> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile long> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile long> : public true_type{};
 
-template <> struct is_signed<unsigned char> : public false_type{};
-template <> struct is_signed<const unsigned char> : public false_type{};
-template <> struct is_signed<volatile unsigned char> : public false_type{};
-template <> struct is_signed<const volatile unsigned char> : public false_type{};
-template <> struct is_signed<unsigned short> : public false_type{};
-template <> struct is_signed<const unsigned short> : public false_type{};
-template <> struct is_signed<volatile unsigned short> : public false_type{};
-template <> struct is_signed<const volatile unsigned short> : public false_type{};
-template <> struct is_signed<unsigned int> : public false_type{};
-template <> struct is_signed<const unsigned int> : public false_type{};
-template <> struct is_signed<volatile unsigned int> : public false_type{};
-template <> struct is_signed<const volatile unsigned int> : public false_type{};
-template <> struct is_signed<unsigned long> : public false_type{};
-template <> struct is_signed<const unsigned long> : public false_type{};
-template <> struct is_signed<volatile unsigned long> : public false_type{};
-template <> struct is_signed<const volatile unsigned long> : public false_type{};
-#ifdef BOOST_HAS_LONG_LONG
-template <> struct is_signed< ::boost::long_long_type> : public true_type{};
-template <> struct is_signed<const ::boost::long_long_type> : public true_type{};
-template <> struct is_signed<volatile ::boost::long_long_type> : public true_type{};
-template <> struct is_signed<const volatile ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned short> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned int> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<unsigned long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const unsigned long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile unsigned long> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile unsigned long> : public false_type{};
+#ifndef BOOST_NO_LONG_LONG
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed< ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile ::boost::long_long_type> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile ::boost::long_long_type> : public true_type{};
 
-template <> struct is_signed< ::boost::ulong_long_type> : public false_type{};
-template <> struct is_signed<const ::boost::ulong_long_type> : public false_type{};
-template <> struct is_signed<volatile ::boost::ulong_long_type> : public false_type{};
-template <> struct is_signed<const volatile ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed< ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile ::boost::ulong_long_type> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile ::boost::ulong_long_type> : public false_type{};
 #endif
 #if defined(CHAR_MIN) 
 #if CHAR_MIN != 0
-template <> struct is_signed<char> : public true_type{};
-template <> struct is_signed<const char> : public true_type{};
-template <> struct is_signed<volatile char> : public true_type{};
-template <> struct is_signed<const volatile char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile char> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile char> : public true_type{};
 #else
-template <> struct is_signed<char> : public false_type{};
-template <> struct is_signed<const char> : public false_type{};
-template <> struct is_signed<volatile char> : public false_type{};
-template <> struct is_signed<const volatile char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile char> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile char> : public false_type{};
 #endif
 #endif
 #if defined(WCHAR_MIN) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
 #if WCHAR_MIN != 0
-template <> struct is_signed<wchar_t> : public true_type{};
-template <> struct is_signed<const wchar_t> : public true_type{};
-template <> struct is_signed<volatile wchar_t> : public true_type{};
-template <> struct is_signed<const volatile wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile wchar_t> : public true_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile wchar_t> : public true_type{};
 #else
-template <> struct is_signed<wchar_t> : public false_type{};
-template <> struct is_signed<const wchar_t> : public false_type{};
-template <> struct is_signed<volatile wchar_t> : public false_type{};
-template <> struct is_signed<const volatile wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<volatile wchar_t> : public false_type{};
+BOOST_TYPE_TRAITS_MODULE_EXPORT template <> struct is_signed<const volatile wchar_t> : public false_type{};
 #endif
 #endif
 } // namespace boost