update boost

linx64/include/boost/log/utility/functional/in_range.hpp

@@ -16,6 +16,8 @@
 #define BOOST_LOG_UTILITY_FUNCTIONAL_IN_RANGE_HPP_INCLUDED_
 
 #include <utility>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/log/detail/config.hpp>
 #include <boost/log/utility/functional/logical.hpp> // make_common_integral_type
 #include <boost/log/detail/header.hpp>
@@ -36,17 +38,17 @@ struct in_range_fun
     template< typename T, typename U >
     bool operator() (T const& value, std::pair< U, U > const& rng) const
     {
-        return op(value, rng, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(value, rng, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& value, std::pair< U, U > const& rng, mpl::false_ const&)
+    static bool op(T const& value, std::pair< U, U > const& rng, false_type)
     {
         return (value >= rng.first && value < rng.second);
     }
     template< typename T, typename U >
-    static bool op(T const& value, std::pair< U, U > const& rng, mpl::true_ const&)
+    static bool op(T const& value, std::pair< U, U > const& rng, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return (static_cast< common_integral_type >(value) >= static_cast< common_integral_type >(rng.first))

linx64/include/boost/log/utility/functional/logical.hpp

@@ -21,11 +21,10 @@
 #ifndef BOOST_LOG_UTILITY_FUNCTIONAL_LOGICAL_HPP_INCLUDED_
 #define BOOST_LOG_UTILITY_FUNCTIONAL_LOGICAL_HPP_INCLUDED_
 
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/and.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/log/detail/config.hpp>
 #include <boost/log/detail/header.hpp>
 
@@ -56,8 +55,8 @@ struct make_common_integral_type< T, U, TSizeV, USizeV, true >
 //! Specialization for the case when both types have the same size
 template< typename T, typename U, unsigned int SizeV >
 struct make_common_integral_type< T, U, SizeV, SizeV, false > :
-    public mpl::if_<
-        is_unsigned< T >,
+    public boost::conditional<
+        is_unsigned< T >::value,
         T,
         U
     >
@@ -74,17 +73,17 @@ struct equal_to
     template< typename T, typename U >
     bool operator() (T const& left, U const& right) const
     {
-        return op(left, right, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(left, right, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::false_ const&)
+    static bool op(T const& left, U const& right, false_type)
     {
         return (left == right);
     }
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::true_ const&)
+    static bool op(T const& left, U const& right, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return static_cast< common_integral_type >(left) == static_cast< common_integral_type >(right);
@@ -99,17 +98,17 @@ struct not_equal_to
     template< typename T, typename U >
     bool operator() (T const& left, U const& right) const
     {
-        return op(left, right, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(left, right, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::false_ const&)
+    static bool op(T const& left, U const& right, false_type)
     {
         return (left != right);
     }
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::true_ const&)
+    static bool op(T const& left, U const& right, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return static_cast< common_integral_type >(left) != static_cast< common_integral_type >(right);
@@ -124,17 +123,17 @@ struct less
     template< typename T, typename U >
     bool operator() (T const& left, U const& right) const
     {
-        return op(left, right, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(left, right, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::false_ const&)
+    static bool op(T const& left, U const& right, false_type)
     {
         return (left < right);
     }
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::true_ const&)
+    static bool op(T const& left, U const& right, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return static_cast< common_integral_type >(left) < static_cast< common_integral_type >(right);
@@ -149,17 +148,17 @@ struct greater
     template< typename T, typename U >
     bool operator() (T const& left, U const& right) const
     {
-        return op(left, right, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(left, right, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::false_ const&)
+    static bool op(T const& left, U const& right, false_type)
     {
         return (left > right);
     }
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::true_ const&)
+    static bool op(T const& left, U const& right, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return static_cast< common_integral_type >(left) > static_cast< common_integral_type >(right);
@@ -174,17 +173,17 @@ struct less_equal
     template< typename T, typename U >
     bool operator() (T const& left, U const& right) const
     {
-        return op(left, right, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(left, right, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::false_ const&)
+    static bool op(T const& left, U const& right, false_type)
     {
         return (left <= right);
     }
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::true_ const&)
+    static bool op(T const& left, U const& right, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return static_cast< common_integral_type >(left) <= static_cast< common_integral_type >(right);
@@ -199,17 +198,17 @@ struct greater_equal
     template< typename T, typename U >
     bool operator() (T const& left, U const& right) const
     {
-        return op(left, right, typename mpl::and_< is_integral< T >, is_integral< U > >::type());
+        return op(left, right, integral_constant< bool, is_integral< T >::value && is_integral< U >::value >());
     }
 
 private:
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::false_ const&)
+    static bool op(T const& left, U const& right, false_type)
     {
         return (left >= right);
     }
     template< typename T, typename U >
-    static bool op(T const& left, U const& right, mpl::true_ const&)
+    static bool op(T const& left, U const& right, true_type)
     {
         typedef typename aux::make_common_integral_type< T, U >::type common_integral_type;
         return static_cast< common_integral_type >(left) >= static_cast< common_integral_type >(right);