Stop using mpl binary logic classes in indirect_traits

Was going to use the ice_* classes from type traits, but they're deprecated.

include/boost/detail/indirect_traits.hpp

@@ -4,6 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef INDIRECT_TRAITS_DWA2002131_HPP
 # define INDIRECT_TRAITS_DWA2002131_HPP
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/type_traits/is_function.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/is_pointer.hpp>
@@ -17,12 +18,8 @@
 # include <boost/type_traits/remove_pointer.hpp>
 
 # include <boost/detail/workaround.hpp>
+# include <boost/detail/select_type.hpp>
 
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/not.hpp>
 # include <boost/mpl/aux_/lambda_support.hpp>
 
 
@@ -31,24 +28,24 @@ namespace boost { namespace detail {
 namespace indirect_traits {
 
 template <class T>
-struct is_reference_to_const : mpl::false_
+struct is_reference_to_const : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_const<T const&> : mpl::true_
+struct is_reference_to_const<T const&> : boost::true_type
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template<class T>
-struct is_reference_to_const<T const volatile&> : mpl::true_
+struct is_reference_to_const<T const volatile&> : boost::true_type
 {
 };
-#   endif 
+#   endif
 
 template <class T>
-struct is_reference_to_function : mpl::false_
+struct is_reference_to_function : boost::false_type
 {
 };
 
@@ -58,7 +55,7 @@ struct is_reference_to_function<T&> : is_function<T>
 };
 
 template <class T>
-struct is_pointer_to_function : mpl::false_
+struct is_pointer_to_function : boost::false_type
 {
 };
 
@@ -70,7 +67,7 @@ struct is_pointer_to_function<T*> : is_function<T>
 };
 
 template <class T>
-struct is_reference_to_member_function_pointer_impl : mpl::false_
+struct is_reference_to_member_function_pointer_impl : boost::false_type
 {
 };
 
@@ -90,13 +87,13 @@ struct is_reference_to_member_function_pointer
 
 template <class T>
 struct is_reference_to_function_pointer_aux
-    : mpl::and_<
-          is_reference<T>
-        , is_pointer_to_function<
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_pointer_to_function<
               typename remove_cv<
                   typename remove_reference<T>::type
               >::type
-          >
+          >::value
       >
 {
     // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
@@ -104,77 +101,76 @@ struct is_reference_to_function_pointer_aux
 
 template <class T>
 struct is_reference_to_function_pointer
-    : mpl::if_<
-          is_reference_to_function<T>
-        , mpl::false_
+    : boost::detail::if_true<
+          is_reference_to_function<T>::value
+      >::template then<
+          boost::false_type
         , is_reference_to_function_pointer_aux<T>
-     >::type
+      >::type
 {
 };
 
 template <class T>
 struct is_reference_to_non_const
-    : mpl::and_<
-          is_reference<T>
-        , mpl::not_<
-             is_reference_to_const<T>
-          >
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          !is_reference_to_const<T>::value
       >
 {
 };
 
 template <class T>
-struct is_reference_to_volatile : mpl::false_
+struct is_reference_to_volatile : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_volatile<T volatile&> : mpl::true_
+struct is_reference_to_volatile<T volatile&> : boost::true_type
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template <class T>
-struct is_reference_to_volatile<T const volatile&> : mpl::true_
+struct is_reference_to_volatile<T const volatile&> : boost::true_type
 {
 };
-#   endif 
+#   endif
 
 
 template <class T>
-struct is_reference_to_pointer : mpl::false_
+struct is_reference_to_pointer : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T*&> : mpl::true_
+struct is_reference_to_pointer<T*&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const&> : mpl::true_
+struct is_reference_to_pointer<T* const&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* volatile&> : mpl::true_
+struct is_reference_to_pointer<T* volatile&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const volatile&> : mpl::true_
+struct is_reference_to_pointer<T* const volatile&> : boost::true_type
 {
 };
 
 template <class T>
 struct is_reference_to_class
-    : mpl::and_<
-          is_reference<T>
-        , is_class<
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_class<
               typename remove_cv<
                   typename remove_reference<T>::type
               >::type
-          >
+          >::value
       >
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
@@ -182,13 +178,13 @@ struct is_reference_to_class
 
 template <class T>
 struct is_pointer_to_class
-    : mpl::and_<
-          is_pointer<T>
-        , is_class<
+    : boost::integral_constant<bool,
+          is_pointer<T>::value &&
+          is_class<
               typename remove_cv<
                   typename remove_pointer<T>::type
               >::type
-          >
+          >::value
       >
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))