passenger 6.0.8 → 6.0.9

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

@@ -119,11 +119,11 @@ public:
     for (std::size_t dim = 0; dim != dimension; ++dim)
     {
       const typename Nb2Table::value_type poly = Nb2Table::polynomial(dim);
-      if (poly > std::numeric_limits<value_type>::max()) {
+      if (poly > (std::numeric_limits<value_type>::max)()) {
         boost::throw_exception( std::range_error("niederreiter_base2: polynomial value outside the given value type range") );
       }
 
-      const unsigned degree = multiprecision::msb(poly); // integer log2(poly)
+      const unsigned degree = qrng_detail::msb(poly); // integer log2(poly)
       const unsigned space_required = degree * ((bit_count / degree) + 1); // ~ degree + bit_count
 
       v.resize(degree + bit_count - 1);

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

@@ -93,9 +93,9 @@ public:
     BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
 
     /** Returns the smallest value that the \random_device can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
+    static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
     /** Returns the largest value that the \random_device can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return ~0u; }
+    static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return ~0u; }
 
     /** Constructs a @c random_device, optionally using the default device. */
     BOOST_RANDOM_DECL random_device();

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

@@ -173,10 +173,10 @@ public:
     { detail::generate_from_int(*this, first, last); }
 
     /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return (base_type::min)(); }
     /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return (base_type::max)(); }
 
     /** Writes a @c shuffle_order_engine to a @c std::ostream. */

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

@@ -11,6 +11,7 @@
 
 #include <boost/random/detail/sobol_table.hpp>
 #include <boost/random/detail/gray_coded_qrng.hpp>
+#include <boost/assert.hpp>
 
 namespace boost {
 namespace random {
@@ -58,10 +59,10 @@ public:
     for (std::size_t dim = 1; dim < dimension; ++dim)
     {
       const typename SobolTables::value_type poly = SobolTables::polynomial(dim-1);
-      if (poly > std::numeric_limits<value_type>::max()) {
+      if (poly > (std::numeric_limits<value_type>::max)()) {
         boost::throw_exception( std::range_error("sobol: polynomial value outside the given value type range") );
       }
-      const unsigned degree = multiprecision::msb(poly); // integer log2(poly)
+      const unsigned degree = qrng_detail::msb(poly); // integer log2(poly)
 
       // set initial values of m from table
       for (unsigned k = 0; k != degree; ++k)

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

@@ -189,10 +189,10 @@ public:
     }
 
     /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return 0; }
     /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return boost::low_bits_mask_t<w>::sig_bits; }
 
     /** Returns the next value of the generator. */
@@ -421,10 +421,10 @@ public:
     }
 
     /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return result_type(0); }
     /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return result_type(1); }
 
     /** Returns the next value of the generator. */

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

@@ -19,10 +19,10 @@
 #ifndef BOOST_RANDOM_TRAITS_HPP
 #define BOOST_RANDOM_TRAITS_HPP
 
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_signed.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
-#include <boost/mpl/bool.hpp>
 #include <limits>
 
 namespace boost {
@@ -92,12 +92,12 @@ namespace traits {
    */
    template <class T>
    struct is_integral
-      : public mpl::bool_<boost::is_integral<T>::value || (std::numeric_limits<T>::is_integer)>
+      : public integral_constant<bool, boost::is_integral<T>::value || (std::numeric_limits<T>::is_integer)>
    {};
    /** \brief Traits class that indicates whether type T is a signed integer
    */
    template <class T> struct is_signed
-      : public mpl::bool_ < boost::is_signed<T>::value || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed)>
+      : public integral_constant<bool, boost::is_signed<T>::value || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed)>
    {};
 
 }

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

@@ -29,9 +29,9 @@
 #include <boost/random/detail/uniform_int_float.hpp>
 #include <boost/random/detail/signed_unsigned_tools.hpp>
 #include <boost/random/traits.hpp>
-#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 #ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #endif
 
 namespace boost {
@@ -49,7 +49,7 @@ namespace detail {
 template<class Engine, class T>
 T generate_uniform_int(
     Engine& eng, T min_value, T max_value,
-    boost::mpl::true_ /** is_integral<Engine::result_type> */)
+    boost::true_type /** is_integral<Engine::result_type> */)
 {
     typedef T result_type;
     typedef typename boost::random::traits::make_unsigned_or_unbounded<T>::type range_type;
@@ -167,7 +167,7 @@ T generate_uniform_int(
                 eng,
                 static_cast<range_type>(0),
                 static_cast<range_type>(range/mult),
-                boost::mpl::true_());
+                boost::true_type());
         if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment)) {
           // The multiplcation would overflow.  Reject immediately.
           continue;
@@ -187,7 +187,7 @@ T generate_uniform_int(
       }
     } else {                   // brange > range
 #ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-      typedef typename mpl::if_c<
+      typedef typename conditional<
          std::numeric_limits<range_type>::is_specialized && std::numeric_limits<base_unsigned>::is_specialized
          && (std::numeric_limits<range_type>::digits >= std::numeric_limits<base_unsigned>::digits),
          range_type, base_unsigned>::type mixed_range_type;
@@ -234,10 +234,10 @@ T generate_uniform_int(
 template<class Engine, class T>
 inline T generate_uniform_int(
     Engine& eng, T min_value, T max_value,
-    boost::mpl::false_ /** is_integral<Engine::result_type> */)
+    boost::false_type /** is_integral<Engine::result_type> */)
 {
     uniform_int_float<Engine> wrapper(eng);
-    return generate_uniform_int(wrapper, min_value, max_value, boost::mpl::true_());
+    return generate_uniform_int(wrapper, min_value, max_value, boost::true_type());
 }
 
 template<class Engine, class T>

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

@@ -24,7 +24,6 @@
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/signed_unsigned_tools.hpp>
 #include <boost/type_traits/is_integral.hpp>
-#include <boost/mpl/bool.hpp>
 
 namespace boost {
 namespace random {
@@ -33,7 +32,7 @@ namespace detail {
 template<class Engine, class T>
 T generate_uniform_real(
     Engine& eng, T min_value, T max_value,
-    boost::mpl::false_  /** is_integral<Engine::result_type> */)
+    boost::false_type  /** is_integral<Engine::result_type> */)
 {
     for(;;) {
         typedef T result_type;
@@ -49,7 +48,7 @@ T generate_uniform_real(
 template<class Engine, class T>
 T generate_uniform_real(
     Engine& eng, T min_value, T max_value,
-    boost::mpl::true_  /** is_integral<Engine::result_type> */)
+    boost::true_type  /** is_integral<Engine::result_type> */)
 {
     for(;;) {
         typedef T result_type;

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

@@ -28,10 +28,9 @@
 #include <boost/random/detail/signed_unsigned_tools.hpp>
 #include <boost/random/uniform_01.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/mpl/bool.hpp>
 
 #ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #endif
 
 namespace boost {
@@ -237,7 +236,7 @@ private:
     
     // \cond show_private
     template<class Engine>
-    result_type generate(Engine& eng, boost::mpl::true_) const
+    result_type generate(Engine& eng, boost::true_type) const
     {
         // equivalent to (eng() - eng.min()) % (_max - _min + 1) + _min,
         // but guarantees no overflow.
@@ -245,7 +244,7 @@ private:
         typedef typename boost::random::traits::make_unsigned<base_result>::type base_unsigned;
         typedef typename boost::random::traits::make_unsigned_or_unbounded<result_type>::type range_type;
 #ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-        typedef typename mpl::if_c<
+        typedef typename conditional<
            std::numeric_limits<range_type>::is_specialized && std::numeric_limits<base_unsigned>::is_specialized
            && (std::numeric_limits<range_type>::digits >= std::numeric_limits<base_unsigned>::digits),
            range_type, base_unsigned>::type mixed_range_type;
@@ -274,7 +273,7 @@ private:
     }
     
     template<class Engine>
-    result_type generate(Engine& eng, boost::mpl::false_) const
+    result_type generate(Engine& eng, boost::false_type) const
     {
         typedef typename Engine::result_type base_result;
         typedef typename boost::random::traits::make_unsigned<result_type>::type range_type;

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

@@ -135,9 +135,11 @@ public:
     }
 
     /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return (std::min)((URNG1::min)(), (URNG2::min)()); }
+    static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    { return (URNG1::min)()<(URNG2::min)()?(URNG1::min)():(URNG2::min)(); }
     /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return (std::max)((URNG1::min)(), (URNG2::max)()); }
+    static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    { return (URNG1::max)()>(URNG2::max)()?(URNG1::max)():(URNG2::max)(); }
 
     /**
      * Writes the textual representation of the generator to a @c std::ostream.

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

@@ -21,6 +21,7 @@
 //    Nickolay Mladenov, for the implementation of operator+=
 
 //  Revision History
+//  12 Nov 20  Fix operators to work with C++20 rules (Glen Joseph Fernandes)
 //  02 Sep 13  Remove unneeded forward declarations; tweak private helper
 //             function (Daryle Walker)
 //  30 Aug 13  Improve exception safety of "assign"; start modernizing I/O code
@@ -74,7 +75,6 @@
 #include <cstddef>               // for NULL
 #include <stdexcept>             // for std::domain_error
 #include <string>                // for std::string implicit constructor
-#include <boost/operators.hpp>   // for boost::addable etc
 #include <cstdlib>               // for std::abs
 #include <boost/call_traits.hpp> // for boost::call_traits
 #include <boost/detail/workaround.hpp> // for BOOST_WORKAROUND
@@ -709,7 +709,7 @@ inline typename boost::enable_if_c <
    rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, bool>::type
    operator <= (const rational<IntType>& a, const Arg& b)
 {
-      return !(a > b);
+      return !a.operator>(b);
 }
 template <class Arg, class IntType>
 BOOST_CXX14_CONSTEXPR
@@ -726,7 +726,7 @@ inline typename boost::enable_if_c <
    rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, bool>::type
    operator >= (const rational<IntType>& a, const Arg& b)
 {
-      return !(a < b);
+      return !a.operator<(b);
 }
 template <class Arg, class IntType>
 BOOST_CXX14_CONSTEXPR
@@ -743,7 +743,7 @@ inline typename boost::enable_if_c <
    rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, bool>::type
    operator != (const rational<IntType>& a, const Arg& b)
 {
-      return !(a == b);
+      return !a.operator==(b);
 }
 template <class Arg, class IntType>
 BOOST_CONSTEXPR
@@ -760,7 +760,7 @@ inline typename boost::enable_if_c <
    rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
    operator < (const Arg& b, const rational<IntType>& a)
 {
-      return a > b;
+      return a.operator>(b);
 }
 template <class Arg, class IntType>
 BOOST_CXX14_CONSTEXPR
@@ -768,7 +768,7 @@ inline typename boost::enable_if_c <
    rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
    operator > (const Arg& b, const rational<IntType>& a)
 {
-      return a < b;
+      return a.operator<(b);
 }
 template <class Arg, class IntType>
 BOOST_CONSTEXPR
@@ -776,7 +776,7 @@ inline typename boost::enable_if_c <
    rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
    operator == (const Arg& b, const rational<IntType>& a)
 {
-      return a == b;
+      return a.operator==(b);
 }
 
 // Comparison operators

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

@@ -28,7 +28,11 @@
 #include <boost/regex/config.hpp>
 #endif
 
+#ifdef BOOST_REGEX_CXX03
 #include <boost/regex/v4/regex.hpp>
+#else
+#include <boost/regex/v5/regex.hpp>
+#endif
 
 #endif  // include
 

data/src/cxx_supportlib/vendor-modified/boost/regex/concepts.hpp

@@ -31,6 +31,12 @@
 #include <vector>
 #include <iostream>
 
+#ifdef BOOST_REGEX_CXX03
+#define RW_NS boost
+#else
+#define RW_NS std
+#endif
+
 namespace boost{
 
 //
@@ -996,37 +1002,36 @@ struct BoostRegexConcept
       out = regex_format(out, m_cresults, func2b);
       out = regex_format(out, m_cresults, func1b, f);
       out = regex_format(out, m_cresults, func1b);
-      out = regex_format(out, m_cresults, boost::ref(func3b), f);
-      out = regex_format(out, m_cresults, boost::ref(func3b));
-      out = regex_format(out, m_cresults, boost::ref(func2b), f);
-      out = regex_format(out, m_cresults, boost::ref(func2b));
-      out = regex_format(out, m_cresults, boost::ref(func1b), f);
-      out = regex_format(out, m_cresults, boost::ref(func1b));
-      out = regex_format(out, m_cresults, boost::cref(func3b), f);
-      out = regex_format(out, m_cresults, boost::cref(func3b));
-      out = regex_format(out, m_cresults, boost::cref(func2b), f);
-      out = regex_format(out, m_cresults, boost::cref(func2b));
-      out = regex_format(out, m_cresults, boost::cref(func1b), f);
-      out = regex_format(out, m_cresults, boost::cref(func1b));
-
+      out = regex_format(out, m_cresults, RW_NS::ref(func3b), f);
+      out = regex_format(out, m_cresults, RW_NS::ref(func3b));
+      out = regex_format(out, m_cresults, RW_NS::ref(func2b), f);
+      out = regex_format(out, m_cresults, RW_NS::ref(func2b));
+      out = regex_format(out, m_cresults, RW_NS::ref(func1b), f);
+      out = regex_format(out, m_cresults, RW_NS::ref(func1b));
+      out = regex_format(out, m_cresults, RW_NS::cref(func3b), f);
+      out = regex_format(out, m_cresults, RW_NS::cref(func3b));
+      out = regex_format(out, m_cresults, RW_NS::cref(func2b), f);
+      out = regex_format(out, m_cresults, RW_NS::cref(func2b));
+      out = regex_format(out, m_cresults, RW_NS::cref(func1b), f);
+      out = regex_format(out, m_cresults, RW_NS::cref(func1b));
       m_string += regex_format(m_cresults, func3b, f);
       m_string += regex_format(m_cresults, func3b);
       m_string += regex_format(m_cresults, func2b, f);
       m_string += regex_format(m_cresults, func2b);
       m_string += regex_format(m_cresults, func1b, f);
       m_string += regex_format(m_cresults, func1b);
-      m_string += regex_format(m_cresults, boost::ref(func3b), f);
-      m_string += regex_format(m_cresults, boost::ref(func3b));
-      m_string += regex_format(m_cresults, boost::ref(func2b), f);
-      m_string += regex_format(m_cresults, boost::ref(func2b));
-      m_string += regex_format(m_cresults, boost::ref(func1b), f);
-      m_string += regex_format(m_cresults, boost::ref(func1b));
-      m_string += regex_format(m_cresults, boost::cref(func3b), f);
-      m_string += regex_format(m_cresults, boost::cref(func3b));
-      m_string += regex_format(m_cresults, boost::cref(func2b), f);
-      m_string += regex_format(m_cresults, boost::cref(func2b));
-      m_string += regex_format(m_cresults, boost::cref(func1b), f);
-      m_string += regex_format(m_cresults, boost::cref(func1b));
+      m_string += regex_format(m_cresults, RW_NS::ref(func3b), f);
+      m_string += regex_format(m_cresults, RW_NS::ref(func3b));
+      m_string += regex_format(m_cresults, RW_NS::ref(func2b), f);
+      m_string += regex_format(m_cresults, RW_NS::ref(func2b));
+      m_string += regex_format(m_cresults, RW_NS::ref(func1b), f);
+      m_string += regex_format(m_cresults, RW_NS::ref(func1b));
+      m_string += regex_format(m_cresults, RW_NS::cref(func3b), f);
+      m_string += regex_format(m_cresults, RW_NS::cref(func3b));
+      m_string += regex_format(m_cresults, RW_NS::cref(func2b), f);
+      m_string += regex_format(m_cresults, RW_NS::cref(func2b));
+      m_string += regex_format(m_cresults, RW_NS::cref(func1b), f);
+      m_string += regex_format(m_cresults, RW_NS::cref(func1b));
 
       out = m_cresults.format(out, func3b, f);
       out = m_cresults.format(out, func3b);
@@ -1034,18 +1039,18 @@ struct BoostRegexConcept
       out = m_cresults.format(out, func2b);
       out = m_cresults.format(out, func1b, f);
       out = m_cresults.format(out, func1b);
-      out = m_cresults.format(out, boost::ref(func3b), f);
-      out = m_cresults.format(out, boost::ref(func3b));
-      out = m_cresults.format(out, boost::ref(func2b), f);
-      out = m_cresults.format(out, boost::ref(func2b));
-      out = m_cresults.format(out, boost::ref(func1b), f);
-      out = m_cresults.format(out, boost::ref(func1b));
-      out = m_cresults.format(out, boost::cref(func3b), f);
-      out = m_cresults.format(out, boost::cref(func3b));
-      out = m_cresults.format(out, boost::cref(func2b), f);
-      out = m_cresults.format(out, boost::cref(func2b));
-      out = m_cresults.format(out, boost::cref(func1b), f);
-      out = m_cresults.format(out, boost::cref(func1b));
+      out = m_cresults.format(out, RW_NS::ref(func3b), f);
+      out = m_cresults.format(out, RW_NS::ref(func3b));
+      out = m_cresults.format(out, RW_NS::ref(func2b), f);
+      out = m_cresults.format(out, RW_NS::ref(func2b));
+      out = m_cresults.format(out, RW_NS::ref(func1b), f);
+      out = m_cresults.format(out, RW_NS::ref(func1b));
+      out = m_cresults.format(out, RW_NS::cref(func3b), f);
+      out = m_cresults.format(out, RW_NS::cref(func3b));
+      out = m_cresults.format(out, RW_NS::cref(func2b), f);
+      out = m_cresults.format(out, RW_NS::cref(func2b));
+      out = m_cresults.format(out, RW_NS::cref(func1b), f);
+      out = m_cresults.format(out, RW_NS::cref(func1b));
 
       m_string += m_cresults.format(func3b, f);
       m_string += m_cresults.format(func3b);
@@ -1053,18 +1058,18 @@ struct BoostRegexConcept
       m_string += m_cresults.format(func2b);
       m_string += m_cresults.format(func1b, f);
       m_string += m_cresults.format(func1b);
-      m_string += m_cresults.format(boost::ref(func3b), f);
-      m_string += m_cresults.format(boost::ref(func3b));
-      m_string += m_cresults.format(boost::ref(func2b), f);
-      m_string += m_cresults.format(boost::ref(func2b));
-      m_string += m_cresults.format(boost::ref(func1b), f);
-      m_string += m_cresults.format(boost::ref(func1b));
-      m_string += m_cresults.format(boost::cref(func3b), f);
-      m_string += m_cresults.format(boost::cref(func3b));
-      m_string += m_cresults.format(boost::cref(func2b), f);
-      m_string += m_cresults.format(boost::cref(func2b));
-      m_string += m_cresults.format(boost::cref(func1b), f);
-      m_string += m_cresults.format(boost::cref(func1b));
+      m_string += m_cresults.format(RW_NS::ref(func3b), f);
+      m_string += m_cresults.format(RW_NS::ref(func3b));
+      m_string += m_cresults.format(RW_NS::ref(func2b), f);
+      m_string += m_cresults.format(RW_NS::ref(func2b));
+      m_string += m_cresults.format(RW_NS::ref(func1b), f);
+      m_string += m_cresults.format(RW_NS::ref(func1b));
+      m_string += m_cresults.format(RW_NS::cref(func3b), f);
+      m_string += m_cresults.format(RW_NS::cref(func3b));
+      m_string += m_cresults.format(RW_NS::cref(func2b), f);
+      m_string += m_cresults.format(RW_NS::cref(func2b));
+      m_string += m_cresults.format(RW_NS::cref(func1b), f);
+      m_string += m_cresults.format(RW_NS::cref(func1b));
 
       out = regex_replace(out, m_in, m_in, ce, func3, f);
       out = regex_replace(out, m_in, m_in, ce, func3);
@@ -1072,18 +1077,18 @@ struct BoostRegexConcept
       out = regex_replace(out, m_in, m_in, ce, func2);
       out = regex_replace(out, m_in, m_in, ce, func1, f);
       out = regex_replace(out, m_in, m_in, ce, func1);
-      out = regex_replace(out, m_in, m_in, ce, boost::ref(func3), f);
-      out = regex_replace(out, m_in, m_in, ce, boost::ref(func3));
-      out = regex_replace(out, m_in, m_in, ce, boost::ref(func2), f);
-      out = regex_replace(out, m_in, m_in, ce, boost::ref(func2));
-      out = regex_replace(out, m_in, m_in, ce, boost::ref(func1), f);
-      out = regex_replace(out, m_in, m_in, ce, boost::ref(func1));
-      out = regex_replace(out, m_in, m_in, ce, boost::cref(func3), f);
-      out = regex_replace(out, m_in, m_in, ce, boost::cref(func3));
-      out = regex_replace(out, m_in, m_in, ce, boost::cref(func2), f);
-      out = regex_replace(out, m_in, m_in, ce, boost::cref(func2));
-      out = regex_replace(out, m_in, m_in, ce, boost::cref(func1), f);
-      out = regex_replace(out, m_in, m_in, ce, boost::cref(func1));
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func3), f);
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func3));
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func2), f);
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func2));
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func1), f);
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func1));
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func3), f);
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func3));
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func2), f);
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func2));
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func1), f);
+      out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func1));
 
       functor3<match_results<typename string_type::const_iterator> > func3s;
       functor2<match_results<typename string_type::const_iterator> > func2s;
@@ -1094,18 +1099,18 @@ struct BoostRegexConcept
       m_string += regex_replace(m_string, ce, func2s);
       m_string += regex_replace(m_string, ce, func1s, f);
       m_string += regex_replace(m_string, ce, func1s);
-      m_string += regex_replace(m_string, ce, boost::ref(func3s), f);
-      m_string += regex_replace(m_string, ce, boost::ref(func3s));
-      m_string += regex_replace(m_string, ce, boost::ref(func2s), f);
-      m_string += regex_replace(m_string, ce, boost::ref(func2s));
-      m_string += regex_replace(m_string, ce, boost::ref(func1s), f);
-      m_string += regex_replace(m_string, ce, boost::ref(func1s));
-      m_string += regex_replace(m_string, ce, boost::cref(func3s), f);
-      m_string += regex_replace(m_string, ce, boost::cref(func3s));
-      m_string += regex_replace(m_string, ce, boost::cref(func2s), f);
-      m_string += regex_replace(m_string, ce, boost::cref(func2s));
-      m_string += regex_replace(m_string, ce, boost::cref(func1s), f);
-      m_string += regex_replace(m_string, ce, boost::cref(func1s));
+      m_string += regex_replace(m_string, ce, RW_NS::ref(func3s), f);
+      m_string += regex_replace(m_string, ce, RW_NS::ref(func3s));
+      m_string += regex_replace(m_string, ce, RW_NS::ref(func2s), f);
+      m_string += regex_replace(m_string, ce, RW_NS::ref(func2s));
+      m_string += regex_replace(m_string, ce, RW_NS::ref(func1s), f);
+      m_string += regex_replace(m_string, ce, RW_NS::ref(func1s));
+      m_string += regex_replace(m_string, ce, RW_NS::cref(func3s), f);
+      m_string += regex_replace(m_string, ce, RW_NS::cref(func3s));
+      m_string += regex_replace(m_string, ce, RW_NS::cref(func2s), f);
+      m_string += regex_replace(m_string, ce, RW_NS::cref(func2s));
+      m_string += regex_replace(m_string, ce, RW_NS::cref(func1s), f);
+      m_string += regex_replace(m_string, ce, RW_NS::cref(func1s));
    }
 
    std::basic_ostream<value_type> m_stream;