seed.hpp in passenger-6.0.9

- old
+ new

@@ -15,15 +15,14 @@
 
 #include <boost/config.hpp>
 
 // Sun seems to have trouble with the use of SFINAE for the
 // templated constructor.  So does Borland.
-#if !defined(BOOST_NO_SFINAE) && !defined(__SUNPRO_CC) && !defined(__BORLANDC__)
+#if !defined(BOOST_NO_SFINAE) && !defined(__SUNPRO_CC) && !defined(BOOST_BORLANDC)
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/mpl/bool.hpp>
 
 namespace boost {
 namespace random {
 namespace detail {
 
@@ -62,54 +61,53 @@
 }
 
 #else
 
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/mpl/bool.hpp>
 
 #define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
     Self(Self& other) { *this = other; }                                \
     Self(const Self& other) { *this = other; }                          \
     template<class Generator>                                           \
     explicit Self(Generator& gen) {                                     \
         boost_random_constructor_impl(gen, ::boost::is_arithmetic<Generator>());\
     }                                                                   \
     template<class Generator>                                           \
-    void boost_random_constructor_impl(Generator& gen, ::boost::mpl::false_)
+    void boost_random_constructor_impl(Generator& gen, ::boost::false_type)
 
 #define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen)    \
     template<class Generator>                                       \
     void seed(Generator& gen) {                                     \
         boost_random_seed_impl(gen, ::boost::is_arithmetic<Generator>());\
     }\
     template<class Generator>\
-    void boost_random_seed_impl(Generator& gen, ::boost::mpl::false_)
+    void boost_random_seed_impl(Generator& gen, ::boost::false_type)
 
 #define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
     Self(Self& other) { *this = other; }                                \
     Self(const Self& other) { *this = other; }                          \
     template<class SeedSeq>                                             \
     explicit Self(SeedSeq& seq) {                                       \
         boost_random_constructor_impl(seq, ::boost::is_arithmetic<SeedSeq>());\
     }                                                                   \
     template<class SeedSeq>                                             \
-    void boost_random_constructor_impl(SeedSeq& seq, ::boost::mpl::false_)
+    void boost_random_constructor_impl(SeedSeq& seq, ::boost::false_type)
 
 #define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)           \
     template<class SeedSeq>                                             \
     void seed(SeedSeq& seq) {                                           \
         boost_random_seed_impl(seq, ::boost::is_arithmetic<SeedSeq>()); \
     }                                                                   \
     template<class SeedSeq>                                             \
-    void boost_random_seed_impl(SeedSeq& seq, ::boost::mpl::false_)
+    void boost_random_seed_impl(SeedSeq& seq, ::boost::false_type)
 
 #define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
-    explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::mpl::true_()); }\
-    void boost_random_constructor_impl(const T& x, ::boost::mpl::true_)
+    explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::true_type()); }\
+    void boost_random_constructor_impl(const T& x, ::boost::true_type)
 
 #define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
-    void seed(const T& x) { boost_random_seed_impl(x, ::boost::mpl::true_()); }\
-    void boost_random_seed_impl(const T& x, ::boost::mpl::true_)
+    void seed(const T& x) { boost_random_seed_impl(x, ::boost::true_type()); }\
+    void boost_random_seed_impl(const T& x, ::boost::true_type)
 
 #endif
 
 #endif