passenger 6.0.25 → 6.0.27

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

@@ -25,21 +25,19 @@ class tc_optional_base : public optional_tag
   protected:
     typedef T &       reference_type ;
     typedef T const&  reference_const_type ;
-#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     typedef T &&  rval_reference_type ;
     typedef T &&  reference_type_of_temporary_wrapper ;
-#endif
     typedef T *         pointer_type ;
     typedef T const*    pointer_const_type ;
     typedef T const&    argument_type ;
 
     tc_optional_base()
       :
-      m_initialized(false) {}
+      m_initialized(false), m_storage() {}
 
     tc_optional_base ( none_t )
       :
-      m_initialized(false) {}
+      m_initialized(false), m_storage() {}
 
     tc_optional_base ( init_value_tag, argument_type val )
       :
@@ -51,31 +49,14 @@ class tc_optional_base : public optional_tag
 
     // tc_optional_base ( tc_optional_base const& ) = default;
 
-
-#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
-
     template<class Expr, class PtrExpr>
     explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag )
       :
       m_initialized(false)
     {
-      construct(boost::forward<Expr>(expr),tag);
-    }
-
-#else
-    // This is used for both converting and in-place constructions.
-    // Derived classes use the 'tag' to select the appropriate
-    // implementation (the correct 'construct()' overload)
-    template<class Expr>
-    explicit tc_optional_base ( Expr const& expr, Expr const* tag )
-      :
-      m_initialized(false)
-    {
-      construct(expr,tag);
+      construct(optional_detail::forward<Expr>(expr),tag);
     }
 
-#endif
-
     // tc_optional_base& operator= ( tc_optional_base const& ) = default;
     // ~tc_optional_base() = default;
 
@@ -99,7 +80,6 @@ class tc_optional_base : public optional_tag
       m_initialized = rhs.is_initialized();
     }
 
-#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // move-assigns from another _convertible_ optional<U> (deep-moves from the rhs value)
     template<class U>
     void assign ( optional<U>&& rhs )
@@ -109,7 +89,6 @@ class tc_optional_base : public optional_tag
         m_storage = static_cast<ref_type>(rhs.get());
       m_initialized = rhs.is_initialized();
     }
-#endif
 
     void assign ( argument_type val )
     {
@@ -120,19 +99,11 @@ class tc_optional_base : public optional_tag
 
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 
-#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     template<class Expr, class ExprPtr>
     void assign_expr ( Expr&& expr, ExprPtr const* tag )
     {
-       construct(boost::forward<Expr>(expr),tag);
+       construct(optional_detail::forward<Expr>(expr),tag);
     }
-#else
-    template<class Expr>
-    void assign_expr ( Expr const& expr, Expr const* tag )
-    {
-      construct(expr,tag);
-    }
-#endif
 
 #endif
 
@@ -162,20 +133,19 @@ class tc_optional_base : public optional_tag
      }
 
 
-#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     // Constructs in-place
     // upon exception *this is always uninitialized
     template<class... Args>
     void construct ( in_place_init_t, Args&&... args )
     {
-      m_storage = value_type( boost::forward<Args>(args)... ) ;
+      m_storage = value_type( optional_detail::forward<Args>(args)... ) ;
       m_initialized = true ;
     }
 
     template<class... Args>
     void emplace_assign ( Args&&... args )
     {
-      construct(in_place_init, boost::forward<Args>(args)...);
+      construct(in_place_init, optional_detail::forward<Args>(args)...);
     }
 
     template<class... Args>
@@ -183,7 +153,7 @@ class tc_optional_base : public optional_tag
       :
       m_initialized(false)
     {
-      construct(in_place_init, boost::forward<Args>(args)...);
+      construct(in_place_init, optional_detail::forward<Args>(args)...);
     }
 
     template<class... Args>
@@ -192,148 +162,11 @@ class tc_optional_base : public optional_tag
       m_initialized(false)
     {
       if ( cond )
-        construct(in_place_init, boost::forward<Args>(args)...);
-    }
-#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
-    template<class Arg>
-    void construct ( in_place_init_t, Arg&& arg )
-     {
-       m_storage = value_type( boost::forward<Arg>(arg) );
-       m_initialized = true ;
-     }
-
-    void construct ( in_place_init_t )
-     {
-       m_storage = value_type();
-       m_initialized = true ;
-     }
-
-    template<class Arg>
-    void emplace_assign ( Arg&& arg )
-     {
-       construct(in_place_init, boost::forward<Arg>(arg)) ;
-     }
-
-    void emplace_assign ()
-     {
-       construct(in_place_init) ;
-     }
-
-    template<class Arg>
-    explicit tc_optional_base ( in_place_init_t, Arg&& arg )
-      :
-      m_initialized(false)
-    {
-      construct(in_place_init, boost::forward<Arg>(arg));
-    }
-
-    explicit tc_optional_base ( in_place_init_t )
-      :
-      m_initialized(false), m_storage() {}
-
-    template<class Arg>
-    explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg&& arg )
-      :
-      m_initialized(false)
-    {
-      if ( cond )
-        construct(in_place_init, boost::forward<Arg>(arg));
-    }
-
-    explicit tc_optional_base ( in_place_init_if_t, bool cond )
-      :
-      m_initialized(false)
-    {
-      if ( cond )
-        construct(in_place_init);
-    }
-
-#else
-
-    template<class Arg>
-    void construct ( in_place_init_t, const Arg& arg )
-     {
-       m_storage = value_type( arg );
-       m_initialized = true ;
-     }
-
-    template<class Arg>
-    void construct ( in_place_init_t, Arg& arg )
-     {
-       m_storage = value_type( arg );
-       m_initialized = true ;
-     }
-
-    void construct ( in_place_init_t )
-     {
-       m_storage = value_type();
-       m_initialized = true ;
-     }
-
-    template<class Arg>
-    void emplace_assign ( const Arg& arg )
-    {
-      construct(in_place_init, arg);
-    }
-
-    template<class Arg>
-    void emplace_assign ( Arg& arg )
-    {
-      construct(in_place_init, arg);
-    }
-
-    void emplace_assign ()
-    {
-      construct(in_place_init);
-    }
-
-    template<class Arg>
-    explicit tc_optional_base ( in_place_init_t, const Arg& arg )
-      : m_initialized(false)
-    {
-      construct(in_place_init, arg);
-    }
-
-    template<class Arg>
-    explicit tc_optional_base ( in_place_init_t, Arg& arg )
-      : m_initialized(false)
-    {
-      construct(in_place_init, arg);
-    }
-
-    explicit tc_optional_base ( in_place_init_t )
-      : m_initialized(false)
-    {
-      construct(in_place_init);
-    }
-
-    template<class Arg>
-    explicit tc_optional_base ( in_place_init_if_t, bool cond, const Arg& arg )
-      : m_initialized(false)
-    {
-      if ( cond )
-        construct(in_place_init, arg);
-    }
-
-    template<class Arg>
-    explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg& arg )
-      : m_initialized(false)
-    {
-      if ( cond )
-        construct(in_place_init, arg);
-    }
-
-    explicit tc_optional_base ( in_place_init_if_t, bool cond )
-      : m_initialized(false)
-    {
-      if ( cond )
-        construct(in_place_init);
+        construct(in_place_init, optional_detail::forward<Args>(args)...);
     }
-#endif
 
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 
-#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Constructs in-place using the given factory
     template<class Expr>
     void construct ( Expr&& factory, in_place_factory_base const* )
@@ -365,42 +198,8 @@ class tc_optional_base : public optional_tag
        construct(factory,tag);
      }
 
-#else
-    // Constructs in-place using the given factory
-    template<class Expr>
-    void construct ( Expr const& factory, in_place_factory_base const* )
-     {
-       boost_optional_detail::construct<value_type>(factory, boost::addressof(m_storage));
-       m_initialized = true ;
-     }
-
-    // Constructs in-place using the given typed factory
-    template<class Expr>
-    void construct ( Expr const& factory, typed_in_place_factory_base const* )
-     {
-       factory.apply(boost::addressof(m_storage)) ;
-       m_initialized = true ;
-     }
-
-    template<class Expr>
-    void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
-     {
-       destroy();
-       construct(factory,tag);
-     }
-
-    // Constructs in-place using the given typed factory
-    template<class Expr>
-    void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
-     {
-       destroy();
-       construct(factory,tag);
-     }
-#endif
-
 #endif
 
-#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Constructs using any expression implicitly convertible to the single argument
     // of a one-argument T constructor.
     // Converting constructions of optional<T> from optional<U> uses this function with
@@ -408,7 +207,7 @@ class tc_optional_base : public optional_tag
     template<class Expr>
     void construct ( Expr&& expr, void const* )
     {
-      m_storage = value_type(boost::forward<Expr>(expr)) ;
+      m_storage = value_type(optional_detail::forward<Expr>(expr)) ;
       m_initialized = true ;
     }
 
@@ -419,31 +218,8 @@ class tc_optional_base : public optional_tag
     template<class Expr>
     void assign_expr_to_initialized ( Expr&& expr, void const* )
     {
-      assign_value( boost::forward<Expr>(expr) );
+      assign_value( optional_detail::forward<Expr>(expr) );
     }
-#else
-    // Constructs using any expression implicitly convertible to the single argument
-    // of a one-argument T constructor.
-    // Converting constructions of optional<T> from optional<U> uses this function with
-    // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
-    template<class Expr>
-    void construct ( Expr const& expr, void const* )
-     {
-       m_storage = value_type(expr) ;
-       m_initialized = true ;
-     }
-
-    // Assigns using a form any expression implicitly convertible to the single argument
-    // of a T's assignment operator.
-    // Converting assignments of optional<T> from optional<U> uses this function with
-    // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
-    template<class Expr>
-    void assign_expr_to_initialized ( Expr const& expr, void const* )
-     {
-       assign_value(expr);
-     }
-
-#endif
 
 #ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
     // BCB5.64 (and probably lower versions) workaround.
@@ -458,7 +234,7 @@ class tc_optional_base : public optional_tag
     // For VC<=70 compilers this workaround doesn't work because the compiler issues and error
     // instead of choosing the wrong overload
     //
-#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
     // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
     template<class Expr>
     void construct ( Expr&& expr, optional_tag const* )
@@ -467,30 +243,14 @@ class tc_optional_base : public optional_tag
        {
          // An exception can be thrown here.
          // It it happens, THIS will be left uninitialized.
-         m_storage = value_type(boost::move(expr.get())) ;
-         m_initialized = true ;
-       }
-     }
-#else
-    // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
-    template<class Expr>
-    void construct ( Expr const& expr, optional_tag const* )
-     {
-       if ( expr.is_initialized() )
-       {
-         // An exception can be thrown here.
-         // It it happens, THIS will be left uninitialized.
-         m_storage = value_type(expr.get()) ;
+         m_storage = value_type(optional_detail::move(expr.get())) ;
          m_initialized = true ;
        }
      }
-#endif
 #endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
 
     void assign_value ( argument_type val ) { m_storage = val; }
-#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     void assign_value ( rval_reference_type val ) { m_storage = static_cast<rval_reference_type>(val); }
-#endif
 
     void destroy()
     {

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

@@ -0,0 +1,41 @@
+// Copyright (C) 2024 Ryan Malcolm Underwood.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  typenametea@gmail.com
+
+#ifndef BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_UTILITY_RMU_06OCT2024_HPP
+#define BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_UTILITY_RMU_06OCT2024_HPP
+
+namespace boost {
+namespace optional_detail {
+
+// Workaround: forward and move aren't constexpr in C++11
+template <class T>
+inline constexpr T&& forward(typename boost::remove_reference<T>::type& t) noexcept
+{
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+inline constexpr T&& forward(typename boost::remove_reference<T>::type&& t) noexcept
+{
+  static_assert(!boost::is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue.");
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+inline constexpr typename boost::remove_reference<T>::type&& move(T&& t) noexcept
+{
+  return static_cast<typename boost::remove_reference<T>::type&&>(t);
+}
+
+} // namespace optional_detail
+} // namespace boost
+
+#endif