passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/mp11/list.hpp

@@ -19,6 +19,11 @@
 #include <boost/mp11/detail/config.hpp>
 #include <type_traits>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -469,4 +474,8 @@ template<class L, class Q> using mp_transform_third_q = mp_transform_third<L, Q:
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_LIST_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mp11/version.hpp

@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108300
+#define BOOST_MP11_VERSION 108500
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/none_t.hpp

@@ -14,6 +14,14 @@
 #define BOOST_NONE_T_17SEP2003_HPP
 
 #include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined (BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_REF_QUALIFIERS) \
+|| defined(BOOST_NO_CXX11_LAMBDAS) || defined(BOOST_NO_CXX11_DECLTYPE_N3276) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_DEFAULTED_MOVES) || defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Optional 1.83 and will be removed in Boost.Optional 1.86.")
+
+#endif
 
 namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/old_optional_implementation.hpp

@@ -17,6 +17,7 @@
 #include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/conditional.hpp>
+#include <boost/core/invoke_swap.hpp>
 
 namespace boost {
 
@@ -894,7 +895,7 @@ class optional : public optional_detail::optional_base<T>
       BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
       {
         // allow for Koenig lookup
-        boost::swap(*this, arg);
+        boost::core::invoke_swap(*this, arg);
       }
 
 

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_swap.hpp

@@ -13,7 +13,7 @@
 #ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_SWAP_AJK_28JAN2015_HPP
 #define BOOST_OPTIONAL_DETAIL_OPTIONAL_SWAP_AJK_28JAN2015_HPP
 
-#include <boost/core/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/optional/optional_fwd.hpp>
 
 namespace boost {
@@ -39,8 +39,8 @@ struct swap_selector<true>
         else if ( !hasY )
             y.emplace();
 
-        // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers
-        boost::swap(x.get(), y.get());
+        // Boost.Core.Swap will take care of ADL and workarounds for broken compilers
+        boost::core::invoke_swap(x.get(), y.get());
 
         if( !hasX )
             y = boost::none ;
@@ -64,13 +64,13 @@ struct swap_selector<false>
 {
     template <class T>
     static void optional_swap ( optional<T>& x, optional<T>& y ) 
-    //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y)))
+    //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::core::invoke_swap(*x, *y)))
     {
         if (x)
         {
             if (y)
             {
-                boost::swap(*x, *y);
+                boost::core::invoke_swap(*x, *y);
             }
             else
             {
@@ -105,7 +105,7 @@ struct optional_swap_should_use_default_constructor : has_nothrow_default_constr
 
 template <class T>
 inline void swap ( optional<T>& x, optional<T>& y )
-//BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y)))
+//BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::core::invoke_swap(*x, *y)))
 {
     optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
 }

data/src/cxx_supportlib/vendor-modified/boost/optional/optional.hpp

@@ -30,7 +30,7 @@
 #include <boost/core/addressof.hpp>
 #include <boost/core/enable_if.hpp>
 #include <boost/core/explicit_operator_bool.hpp>
-#include <boost/core/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/optional/bad_optional_access.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
@@ -1260,7 +1260,7 @@ class optional
       BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
       {
         // allow for Koenig lookup
-        boost::swap(*this, arg);
+        boost::core::invoke_swap(*this, arg);
       }
 
 

data/src/cxx_supportlib/vendor-modified/boost/pool/pool.hpp

@@ -360,7 +360,7 @@ class pool: protected simple_segregated_storage < typename UserAllocator::size_t
     size_type max_chunks() const
     { //! Calculated maximum number of memory chunks that can be allocated in a single call by this Pool.
       size_type POD_size = integer::static_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type);
-      return (std::numeric_limits<size_type>::max() - POD_size) / alloc_size();
+      return ((std::numeric_limits<size_type>::max)() - POD_size) / alloc_size();
     }
 
     static void * & nextof(void * const ptr)

data/src/cxx_supportlib/vendor-modified/boost/predef/library/std/msvc.h

@@ -0,0 +1,53 @@
+/*
+Copyright Henrik S. Gaßmann 2023
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_MSVC_H
+#define BOOST_PREDEF_LIBRARY_STD_MSVC_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/* tag::reference[]
+= `BOOST_LIB_STD_MSVC`
+
+https://github.com/microsoft/STL[Microsoft's {CPP} Standard Library].
+If available version number as major, minor, and patch.
+The patch number is derived from `_MSVC_STL_UPDATE` by taking its five last
+digits (see below). This implies that pasting a `_MSVC_STL_UPDATE` value into
+`BOOST_VERSION_NUMBER` will produce a version number that is directly comparable
+to `BOOST_LIB_STD_MSVC`.
+
+[options="header"]
+|===
+| {predef_symbol} | {predef_version}
+
+| `+_MSVC_STL_VERSION+` | {predef_detection}
+
+| `+_MSVC_STL_VERSION+` | VV.R.0
+| `+_MSVC_STL_UPDATE+` | 00.0.0YYYMM
+|===
+*/ // end::reference[]
+
+#define BOOST_LIB_STD_MSVC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(_MSVC_STL_VERSION)
+#   undef BOOST_LIB_STD_MSVC
+#   define BOOST_LIB_STD_MSVC BOOST_PREDEF_MAKE_10_VVR_0PPPPP(_MSVC_STL_VERSION, _MSVC_STL_UPDATE)
+#endif
+
+#if BOOST_LIB_STD_MSVC
+#   define BOOST_LIB_STD_MSVC_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_MSVC_NAME "Microsoft stdlib"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_MSVC, BOOST_LIB_STD_MSVC_NAME)

data/src/cxx_supportlib/vendor-modified/boost/predef/library/std.h

@@ -16,6 +16,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/predef/library/std/libcomo.h>
 #include <boost/predef/library/std/modena.h>
 #include <boost/predef/library/std/msl.h>
+#include <boost/predef/library/std/msvc.h>
 #include <boost/predef/library/std/roguewave.h>
 #include <boost/predef/library/std/sgi.h>
 #include <boost/predef/library/std/stdcpp3.h>

data/src/cxx_supportlib/vendor-modified/boost/predef/make.h

@@ -106,6 +106,10 @@ Macros are:
 */ // end::reference[]
 #define BOOST_PREDEF_MAKE_10_VV00(V) BOOST_VERSION_NUMBER(((V)/100)%100,0,0)
 /* tag::reference[]
+* `BOOST_PREDEF_MAKE_10_VVR_0PPPPP(V, P)`, the second parameter specifies a year-month patch level with the first digit discarded
+*/ // end::reference[]
+#define BOOST_PREDEF_MAKE_10_VVR_0PPPPP(V, P) BOOST_VERSION_NUMBER(((V)/10)%100,(V)%10,(P)%100000)
+/* tag::reference[]
 * `BOOST_PREDEF_MAKE_10_VVRR(V)`
 */ // end::reference[]
 #define BOOST_PREDEF_MAKE_10_VVRR(V) BOOST_VERSION_NUMBER(((V)/100)%100,(V)%100,0)

data/src/cxx_supportlib/vendor-modified/boost/predef/os/vms.h

@@ -14,7 +14,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 /* tag::reference[]
 = `BOOST_OS_VMS`
 
-http://en.wikipedia.org/wiki/Vms[VMS] operating system.
+http://en.wikipedia.org/wiki/OpenVMS[VMS] operating system.
 
 [options="header"]
 |===

data/src/cxx_supportlib/vendor-modified/boost/predef/version.h

@@ -10,6 +10,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/predef/version_number.h>
 
-#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,14,0)
+#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,15,0)
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/preprocessor/variadic/has_opt.hpp

@@ -19,6 +19,8 @@
 # if defined(__cplusplus) && __cplusplus > 201703L
 #  if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 8 && __GNUC__ < 10
 #   define BOOST_PP_VARIADIC_HAS_OPT() 0
+#  elif defined(__clang__) && __clang_major__ < 9
+#   define BOOST_PP_VARIADIC_HAS_OPT() 0
 #  else
 #   include <boost/preprocessor/variadic/detail/has_opt.hpp>
 #   define BOOST_PP_VARIADIC_HAS_OPT() \

data/src/cxx_supportlib/vendor-modified/boost/random/inversive_congruential.hpp

@@ -129,7 +129,7 @@ public:
             _value = x0 % modulus;
         }
         // handle negative seeds
-        if(_value <= 0 && _value != 0) {
+        if(_value < 0) {
             _value += modulus;
         }
         // adjust to the correct range

data/src/cxx_supportlib/vendor-modified/boost/random/splitmix64.hpp

@@ -0,0 +1,203 @@
+/* 
+ * Copyright Sebastiano Vigna 2015.
+ * Copyright Matt Borland 2022.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ * 
+ */
+
+#ifndef BOOST_RANDOM_SPLITMIX64_HPP
+#define BOOST_RANDOM_SPLITMIX64_HPP
+
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include <array>
+#include <string>
+#include <ios>
+#include <type_traits>
+
+namespace boost { namespace random {
+
+/**
+ *  This is a fixed-increment version of Java 8's SplittableRandom generator
+ *  See http://dx.doi.org/10.1145/2714064.2660195 and
+ *  http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html
+ *  It is a very fast generator passing BigCrush, and it can be useful if
+ *  for some reason you absolutely want 64 bits of state; otherwise, we
+ *  rather suggest to use a xoroshiro128+ (for moderately parallel
+ *  computations) or xorshift1024* (for massively parallel computations)
+ *  generator.
+ */
+class splitmix64
+{
+private:
+    std::uint64_t state_;
+
+    inline std::uint64_t concatenate(std::uint32_t word1, std::uint32_t word2) noexcept
+    {
+        return static_cast<std::uint64_t>(word1) << 32 | word2;
+    }
+
+public:
+    using result_type = std::uint64_t;
+    using seed_type = std::uint64_t;
+
+    // Required for old Boost.Random concept
+    static constexpr bool has_fixed_range {false};
+
+    /** Seeds the generator with the default seed. */
+    void seed(result_type value = 0) noexcept
+    {
+        if (value == 0)
+        {
+            state_ = UINT64_C(0xA164B43C8F634A13);
+        }
+        else
+        {
+            state_ = value;
+        }
+    }
+
+    /**
+     * Seeds the generator with 32-bit values produced by @c seq.generate().
+     */
+    template <typename Sseq, typename std::enable_if<!std::is_convertible<Sseq, std::uint64_t>::value, bool>::type = true>
+    void seed(Sseq& seq)
+    {
+        std::array<std::uint32_t, 2> seeds;
+        seq.generate(seeds.begin(), seeds.end());
+
+        state_ = concatenate(seeds[0], seeds[1]);
+    }
+
+    /**
+     * Seeds the generator with 64-bit values produced by @c seq.generate().
+     */
+    template <typename Sseq, typename std::enable_if<!std::is_convertible<Sseq, splitmix64>::value, bool>::type = true>
+    explicit splitmix64(Sseq& seq)
+    {
+        seed(seq);
+    }
+
+    /** Seeds the generator with a user provided seed. */
+    template <typename T, typename std::enable_if<std::is_convertible<T, std::uint64_t>::value, bool>::type = true>
+    void seed(T value = 0) noexcept
+    {
+        seed(static_cast<std::uint64_t>(value));
+    }
+
+    /** Seeds the generator with a user provided seed. */
+    explicit splitmix64(std::uint64_t state = 0) noexcept
+    {
+        seed(state);
+    }
+
+    splitmix64(const splitmix64& other) = default;
+    splitmix64& operator=(const splitmix64& other) = default;
+
+    /**  Returns the next value of the generator. */
+    inline result_type next() noexcept
+    {
+        std::uint64_t z {state_ += UINT64_C(0x9E3779B97F4A7C15)};
+	    z = (z ^ (z >> 30)) * UINT64_C(0xBF58476D1CE4E5B9);
+	    z = (z ^ (z >> 27)) * UINT64_C(0x94D049BB133111EB);
+	    
+        return z ^ (z >> 31);
+    }
+
+    /**  Returns the next value of the generator. */
+    inline result_type operator()() noexcept
+    {
+        return next();
+    }
+
+    /** Advances the state of the generator by @c z. */
+    inline void discard(std::uint64_t z) noexcept
+    {
+        for (std::uint64_t i {}; i < z; ++i)
+        {
+            next();
+        }
+    }
+
+    /**
+     * Returns true if the two generators will produce identical
+     * sequences of values.
+     */
+    inline friend bool operator==(const splitmix64& lhs, const splitmix64& rhs) noexcept
+    {
+        return lhs.state_ == rhs.state_;
+    }
+
+    /**
+     * Returns true if the two generators will produce different
+     * sequences of values.
+     */
+    inline friend bool operator!=(const splitmix64& lhs, const splitmix64& rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /**  Writes a @c splitmix64 to a @c std::ostream. */
+    template <typename CharT, typename Traits>
+    inline friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& ost, 
+                                                               const splitmix64& e)
+    {
+        ost << e.state_;
+        return ost;
+    }
+
+    /**  Writes a @c splitmix64 to a @c std::istream. */
+    template <typename CharT, typename Traits>
+    inline friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& ist,
+                                                               splitmix64& e)
+    {
+        std::string sstate;
+        CharT val;
+        while (ist >> val)
+        {
+            if (std::isdigit(val))
+            {
+                sstate.push_back(val);
+            }
+        }
+        
+        e.state_ = std::strtoull(sstate.c_str(), nullptr, 10);
+
+        return ist;
+    }
+
+    /** Fills a range with random values */
+    template <typename FIter>
+    inline void generate(FIter first, FIter last) noexcept
+    {
+        while (first != last)
+        {
+            *first++ = next();
+        }
+    }
+
+    /**
+     * Returns the largest value that the @c splitmix64
+     * can produce.
+     */
+    static constexpr result_type (max)() noexcept
+    {
+        return (std::numeric_limits<std::uint64_t>::max)();
+    }
+
+    /**
+     * Returns the smallest value that the @c splitmix64
+     * can produce.
+     */
+    static constexpr result_type (min)() noexcept
+    {
+        return (std::numeric_limits<std::uint64_t>::min)();
+    }
+};
+
+}} // Namespace boost::random
+
+#endif // BOOST_RANDOM_SPLITMIX64_HPP

data/src/cxx_supportlib/vendor-modified/boost/random/subtract_with_carry.hpp

@@ -244,10 +244,10 @@ public:
      * Returns true if the two generators will produce identical
      * sequences of values.
      */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_engine, x, y)
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_engine, x_, y)
     {
         for(unsigned int j = 0; j < r; ++j)
-            if(x.compute(j) != y.compute(j))
+            if(x_.compute(j) != y.compute(j))
                 return false;
         return true;
     }
@@ -268,21 +268,21 @@ private:
 
     friend struct detail::subtract_with_carry_discard;
 
-    IntType do_update(std::size_t current, std::size_t short_index, IntType carry)
+    IntType do_update(std::size_t current, std::size_t short_index, IntType carry_)
     {
         IntType delta;
-        IntType temp = x[current] + carry;
+        IntType temp = x[current] + carry_;
         if (x[short_index] >= temp) {
             // x(n) >= 0
             delta =  x[short_index] - temp;
-            carry = 0;
+            carry_ = 0;
         } else {
             // x(n) < 0
             delta = modulus - temp + x[short_index];
-            carry = 1;
+            carry_ = 1;
         }
         x[current] = delta;
-        return carry;
+        return carry_;
     }
     /// \endcond
 
@@ -478,10 +478,10 @@ public:
     }
 
     /** Returns true if the two generators will produce identical sequences. */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_01_engine, x, y)
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_01_engine, x_, y)
     {
         for(unsigned int j = 0; j < r; ++j)
-            if(x.compute(j) != y.compute(j))
+            if(x_.compute(j) != y.compute(j))
                 return false;
         return true;
     }
@@ -498,17 +498,17 @@ private:
 
     friend struct detail::subtract_with_carry_discard;
 
-    RealType do_update(std::size_t current, std::size_t short_index, RealType carry)
+    RealType do_update(std::size_t current, std::size_t short_index, RealType carry_)
     {
-        RealType delta = x[short_index] - x[current] - carry;
+        RealType delta = x[short_index] - x[current] - carry_;
         if(delta < 0) {
             delta += RealType(1);
-            carry = RealType(1)/_modulus;
+            carry_ = RealType(1)/_modulus;
         } else {
-            carry = 0;
+            carry_ = 0;
         }
         x[current] = delta;
-        return carry;
+        return carry_;
     }
     /// \endcond
     std::size_t k;

data/src/cxx_supportlib/vendor-modified/boost/random/uniform_real_distribution.hpp

@@ -95,7 +95,7 @@ public:
         /**
          * Constructs the parameters of a uniform_real_distribution.
          *
-         * Requires min <= max
+         * Requires min < max
          */
         explicit param_type(RealType min_arg = RealType(0.0),
                             RealType max_arg = RealType(1.0))
@@ -148,7 +148,7 @@ public:
      * Constructs a uniform_real_distribution. @c min and @c max are
      * the parameters of the distribution.
      *
-     * Requires: min <= max
+     * Requires: min < max
      */
     explicit uniform_real_distribution(
         RealType min_arg = RealType(0.0),

data/src/cxx_supportlib/vendor-modified/boost/random.hpp

@@ -48,6 +48,7 @@
 #include <boost/random/subtract_with_carry.hpp>
 #include <boost/random/taus88.hpp>
 #include <boost/random/xor_combine.hpp>
+#include <boost/random/splitmix64.hpp>
 
 // misc
 #include <boost/random/generate_canonical.hpp>

data/src/cxx_supportlib/vendor-modified/boost/ratio/config.hpp

@@ -9,93 +9,10 @@
 #ifndef BOOST_RATIO_CONFIG_HPP
 #define BOOST_RATIO_CONFIG_HPP
 
-#include <boost/ratio/detail/requires_cxx11.hpp>
-#include <boost/config.hpp>
-#include <boost/config/pragma_message.hpp>
-#include <boost/cstdint.hpp>
+// This header is no longer useful and is only retained for compatibility
 
+#include <cstdint>
 
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  if ! defined BOOST_NO_CXX11_U16STRING
-#    define BOOST_NO_CXX11_U16STRING
-#  endif
-#  if ! defined BOOST_NO_CXX11_U32STRING
-#    define BOOST_NO_CXX11_U32STRING
-#  endif
-#endif
+#define BOOST_RATIO_INTMAX_C INTMAX_C
 
-
-#if !defined BOOST_RATIO_VERSION
-#define BOOST_RATIO_VERSION 2
-#else
-#if BOOST_RATIO_VERSION!=1  && BOOST_RATIO_VERSION!=2
-#error "BOOST_RATIO_VERSION must be 1 or 2"
-#endif
-#endif
-
-#if BOOST_RATIO_VERSION==1
-#if ! defined BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
-#define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
-#endif
-#endif
-
-#if BOOST_RATIO_VERSION==2
-#if ! defined BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
-#define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
-#endif
-#endif
-
-#ifdef INTMAX_C
-#define BOOST_RATIO_INTMAX_C(a) INTMAX_C(a)
-#elif __cplusplus >= 201103L
-#define BOOST_RATIO_INTMAX_C(a) a##LL
-#else
-#define BOOST_RATIO_INTMAX_C(a) a##L
-#endif
-
-#ifdef UINTMAX_C
-#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
-#elif __cplusplus >= 201103L
-#define BOOST_RATIO_UINTMAX_C(a) a##ULL
-#else
-#define BOOST_RATIO_UINTMAX_C(a) a##UL
-#endif
-
-#define BOOST_RATIO_INTMAX_T_MAX (0x7FFFFFFFFFFFFFFELL)
-
-
-#ifndef BOOST_NO_CXX11_STATIC_ASSERT
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
-#elif defined(BOOST_RATIO_USES_STATIC_ASSERT)
-#include <boost/static_assert.hpp>
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
-#elif defined(BOOST_RATIO_USES_MPL_ASSERT)
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)                                 \
-    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
-#else
-//~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT)
-#define BOOST_RATIO_CONCAT(A,B) A##B
-#define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B)
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1]
-//~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
-#endif
-
-#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT)
-#define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add"
-#define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub"
-#define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul"
-#define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div"
-#define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
-#define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0"
-#define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
-#endif
-
-#if defined(BOOST_RATIO_EXTENSIONS)
-
-BOOST_PRAGMA_MESSAGE("Support for BOOST_RATIO_EXTENSIONS is deprecated and will be removed when Boost.Ratio is implemented in terms of <ratio>.")
-
-#endif
-
-#endif  // header
+#endif  // #ifndef BOOST_RATIO_CONFIG_HPP