passenger 6.2.1 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/container/uses_allocator.hpp

@@ -17,118 +17,25 @@
 namespace boost {
 namespace container {
 
-//! <b>Remark</b>: if a specialization constructible_with_allocator_suffix<X>::value is true, indicates that T may be constructed
-//! with an allocator as its last constructor argument.  Ideally, all constructors of T (including the
-//! copy and move constructors) should have a variant that accepts a final argument of
-//! allocator_type.
-//!
-//! <b>Requires</b>: if a specialization constructible_with_allocator_suffix<X>::value is true, T must have a nested type,
-//! allocator_type and at least one constructor for which allocator_type is the last
-//! parameter.  If not all constructors of T can be called with a final allocator_type argument,
-//! and if T is used in a context where a container must call such a constructor, then the program is
-//! ill-formed.
-//!
-//! <code>
-//!  template <class T, class Allocator = allocator<T> >
-//!  class Z {
-//!    public:
-//!      typedef Allocator allocator_type;
-//!
-//!    // Default constructor with optional allocator suffix
-//!    Z(const allocator_type& a = allocator_type());
-//!
-//!    // Copy constructor and allocator-extended copy constructor
-//!    Z(const Z& zz);
-//!    Z(const Z& zz, const allocator_type& a);
-//! };
-//!
-//! // Specialize trait for class template Z
-//! template <class T, class Allocator = allocator<T> >
-//! struct constructible_with_allocator_suffix<Z<T,Allocator> >
-//! { static const bool value = true;  };
-//! </code>
-//!
-//! <b>Note</b>: This trait is a workaround inspired by "N2554: The Scoped A Model (Rev 2)"
-//! (Pablo Halpern, 2008-02-29) to backport the scoped allocator model to C++03, as
-//! in C++03 there is no mechanism to detect if a type can be constructed from arbitrary arguments.
-//! Applications aiming portability with several compilers should always define this trait.
-//!
-//! In conforming C++11 compilers or compilers supporting SFINAE expressions
-//! (when BOOST_NO_SFINAE_EXPR is NOT defined), this trait is ignored and C++11 rules will be used
-//! to detect if a type should be constructed with suffix or prefix allocator arguments.
-template <class T>
-struct constructible_with_allocator_suffix
-{  BOOST_STATIC_CONSTEXPR bool value = false; };
-
-//! <b>Remark</b>: if a specialization constructible_with_allocator_prefix<X>::value is true, indicates that T may be constructed
-//! with allocator_arg and T::allocator_type as its first two constructor arguments.
-//! Ideally, all constructors of T (including the copy and move constructors) should have a variant
-//! that accepts these two initial arguments.
-//!
-//! <b>Requires</b>: specialization constructible_with_allocator_prefix<X>::value is true, T must have a nested type,
-//! allocator_type and at least one constructor for which allocator_arg_t is the first
-//! parameter and allocator_type is the second parameter.  If not all constructors of T can be
-//! called with these initial arguments, and if T is used in a context where a container must call such
-//! a constructor, then the program is ill-formed.
-//!
-//! <code>
-//! template <class T, class Allocator = allocator<T> >
-//! class Y {
-//!    public:
-//!       typedef Allocator allocator_type;
-//!
-//!       // Default constructor with and allocator-extended default constructor
-//!       Y();
-//!       Y(allocator_arg_t, const allocator_type& a);
-//!
-//!       // Copy constructor and allocator-extended copy constructor
-//!       Y(const Y& yy);
-//!       Y(allocator_arg_t, const allocator_type& a, const Y& yy);
-//!
-//!       // Variadic constructor and allocator-extended variadic constructor
-//!       template<class ...Args> Y(Args&& args...);
-//!       template<class ...Args>
-//!       Y(allocator_arg_t, const allocator_type& a, BOOST_FWD_REF(Args)... args);
-//! };
-//!
-//! // Specialize trait for class template Y
-//! template <class T, class Allocator = allocator<T> >
-//! struct constructible_with_allocator_prefix<Y<T,Allocator> >
-//! { static const bool value = true;  };
-//!
-//! </code>
-//!
-//! <b>Note</b>: This trait is a workaround inspired by "N2554: The Scoped Allocator Model (Rev 2)"
-//! (Pablo Halpern, 2008-02-29) to backport the scoped allocator model to C++03, as
-//! in C++03 there is no mechanism to detect if a type can be constructed from arbitrary arguments.
-//! Applications aiming portability with several compilers should always define this trait.
-//!
-//! In conforming C++11 compilers or compilers supporting SFINAE expressions
-//! (when BOOST_NO_SFINAE_EXPR is NOT defined), this trait is ignored and C++11 rules will be used
-//! to detect if a type should be constructed with suffix or prefix allocator arguments.
-template <class T>
-struct constructible_with_allocator_prefix
-{  BOOST_STATIC_CONSTEXPR bool value = false; };
-
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 namespace dtl {
 
-template<typename T, typename Allocator>
+template<typename T, typename AllocArg>
 struct uses_allocator_imp
 {
    // Use SFINAE (Substitution Failure Is Not An Error) to detect the
-   // presence of an 'allocator_type' nested type convertilble from Allocator.
+   // presence of an 'allocator_type' nested type convertilble from AllocArg.
    private:
    typedef char yes_type;
    struct no_type{ char dummy[2]; };
 
    // Match this function if T::allocator_type exists and is
-   // implicitly convertible from Allocator
+   // implicitly convertible from `AllocArg`
    template <class U>
    static yes_type test(typename U::allocator_type);
 
-   // Match this function if T::allocator_type exists and it's type is `erased_type`.
+   // Match this function if T::allocator_type exists and its type is `erased_type`.
    template <class U, class V>
    static typename dtl::enable_if
       < dtl::is_same<typename U::allocator_type, erased_type>
@@ -136,10 +43,10 @@ struct uses_allocator_imp
       >::type  test(const V&);
 
    // Match this function if TypeT::allocator_type does not exist or is
-   // not convertible from Allocator.
+   // not convertible from `AllocArg`.
    template <typename U>
    static no_type test(...);
-   static Allocator alloc;  // Declared but not defined
+   static AllocArg alloc;  // Declared but not defined
 
    public:
    BOOST_STATIC_CONSTEXPR bool value = sizeof(test<T>(alloc)) == sizeof(yes_type);
@@ -147,23 +54,59 @@ struct uses_allocator_imp
 
 }  //namespace dtl {
 
+template <class T>
+struct constructible_with_allocator_prefix
+{  BOOST_STATIC_CONSTEXPR bool value = false; };
+
+template <class T>
+struct constructible_with_allocator_suffix
+{  BOOST_STATIC_CONSTEXPR bool value = false; };
+
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-//! <b>Remark</b>: Automatically detects whether T has a nested allocator_type that is convertible from
-//! Allocator. Meets the BinaryTypeTrait requirements ([meta.rqmts] 20.4.1). A program may
-//! specialize this type to define uses_allocator<X>::value as true for a T of user-defined type if T does not
-//! have a nested allocator_type but is nonetheless constructible using the specified Allocator where either:
-//! the first argument of a constructor has type allocator_arg_t and the second argument has type Alloc or
-//! the last argument of a constructor has type Alloc.
-//!
-//! <b>Result</b>: uses_allocator<T, Allocator>::value== true if a type T::allocator_type
-//! exists and either is_convertible<Alloc, T::allocator_type>::value != false or T::allocator_type
-//! is an alias `erased_type`. False otherwise.
-template <typename T, typename Allocator>
+//! <b>Remark</b>: Automatically detects whether `T` has a nested `allocator_type` that is convertible from
+//! `AllocArg`. Meets the BinaryTypeTrait requirements ([meta.rqmts] 20.4.1). This trait is used to signal if
+//! type `T` supports <b>uses-allocator construction</b>.
+//! 
+//! <b>uses-allocator construction</b> protocol specifies three conventions of passing an allocator argument
+//! `alloc_arg` of type `AllocArg` to a constructor of some type T in addition to an arbitrary number of arguments
+//! (specified as `args...` in this explanation):
+//! 
+//! * If `T` does not use a compatible allocator (`uses_allocator<T, AllocArg>::value` is false), then `alloc_arg` is ignored
+//!   and `T` is constructed as `T(args...)`
+//! 
+//! * Otherwise, if `uses_allocator<T, AllocArg>::value` is true and `T` is constructible as `T(std::allocator_arg, alloc_arg, args...)`
+//!   then uses-allocator construction uses this form.
+//! 
+//! * Otherwise, if `T` is constructible as `T(args..., alloc_arg)`, then uses-allocator construction uses this form.
+//! 
+//! * Otherwise, as an non-standard extension provided by Boost.Container, `alloc_arg` is ignored and `T(args...)` is called. 
+//!   (Note that this extension is provided to enhance backwards compatibility for types created without uses-allocator 
+//!   construction in mind that declare an `allocator_type` type but are not prepared to be built with an additional allocator argument)
+//!
+//! <b>Result</b>: `uses_allocator<T, AllocArg>::value == true` if a type `T::allocator_type`
+//! exists and either `is_convertible<AllocArg, T::allocator_type>::value == true` or `T::allocator_type`
+//! is an alias of `erased_type`. False otherwise.
+//!
+//! <b>Note</b>: A program may specialize this type to define `uses_allocator<X>::value` as true for a `T` of user-defined type
+//! if `T` does not have a nested `allocator_type` but is nonetheless constructible using the specified `AllocArg`
+//! where either: the first argument of a constructor has type `allocator_arg_t` and the second argument has type `AllocArg`
+//! or the last argument of a constructor has type `AllocArg`.
+
+template <typename T, typename AllocArg>
 struct uses_allocator
-   : dtl::uses_allocator_imp<T, Allocator>
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+   : dtl::uses_allocator_imp<T, AllocArg>
+#endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
 {};
 
+#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+
+template< class T, class AllocArg >
+BOOST_CONSTEXPR bool uses_allocator_v = uses_allocator<T, AllocArg>::value;
+
+#endif   //BOOST_NO_CXX14_VARIABLE_TEMPLATES
+
 }} //namespace boost::container
 
 #endif   //BOOST_CONTAINER_USES_ALLOCATOR_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/uses_allocator_construction.hpp

@@ -0,0 +1,100 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-2025. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_USES_ALLOCATOR_CONSTRUCTION_HPP
+#define BOOST_CONTAINER_USES_ALLOCATOR_CONSTRUCTION_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
+#include <boost/move/utility_core.hpp>
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
+
+namespace boost {
+namespace container {
+
+#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+//! <b>Effects</b>: Creates an object of the given type T by means of uses-allocator
+//!   construction (see `uses_allocator`) at the uninitialized memory, where:
+//!   
+//!   * `p` is the memory location where the object will be placed
+//!   * `alloc_arg` is the allocator argument whose type AllocArg will be used to evaluate uses_allocator<T, AllocArg>::value
+//!   * `args` are the arguments to pass to T's constructor.
+//!
+//! <b>Returns</b>: Pointer to the newly-created object of type T
+//!
+//! <b>Throws</b>: Any exception thrown by the constructor of T.
+template< class T, class AllocArg, class... Args >
+T* uninitialized_construct_using_allocator(T* p, BOOST_FWD_REF(AllocArg) alloc_arg, BOOST_FWD_REF(Args)... args)
+{
+   boost::container::dtl::allocator_traits_dummy<T> atd;
+   boost::container::dtl::dispatch_uses_allocator
+      (atd, boost::forward<AllocArg>(alloc_arg), p, boost::forward<Args>(args)...);
+   return p;
+}
+
+//! <b>Effects</b>: eates an object of the given type T by means of uses-allocator construction
+//!   (see `uses_allocator`), where:
+//!   
+//!   * `alloc_arg` is the allocator argument whose type AllocArg will be used to evaluate uses_allocator<T, AllocArg>::value
+//!   * `args` are the arguments to pass to T's constructor.
+//!
+//! <b>Returns</b>: The newsly created object of type T
+//!
+//! <b>Throws</b>: Any exception thrown by the constructor of T.
+template< class T, class AllocArg, class... Args >
+T make_obj_using_allocator(BOOST_FWD_REF(AllocArg) alloc_arg, BOOST_FWD_REF(Args)... args)
+{
+   return boost::container::dtl::construct_dispatch_uses_allocator<T>
+      (boost::forward<AllocArg>(alloc_arg), boost::forward<Args>(args)...);
+}
+
+#else //BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+#define BOOST_CONTAINER_USES_ALLOCATOR_CONSTRUCTION_CODE(N) \
+   template < typename T, typename AllocArg BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
+   inline T* uninitialized_construct_using_allocator\
+      (T* p, BOOST_FWD_REF(AllocArg) alloc_arg BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {\
+      boost::container::dtl::allocator_traits_dummy<T> atd;\
+      boost::container::dtl::dispatch_uses_allocator\
+         (atd, boost::forward<AllocArg>(alloc_arg), p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      return p;\
+   }\
+   \
+   template <class T, class AllocArg BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
+   inline T make_obj_using_allocator\
+      (BOOST_FWD_REF(AllocArg) alloc_arg BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {\
+      return boost::container::dtl::construct_dispatch_uses_allocator<T>\
+         (boost::forward<AllocArg>(alloc_arg) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+   }\
+//
+BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_USES_ALLOCATOR_CONSTRUCTION_CODE)
+#undef BOOST_CONTAINER_USES_ALLOCATOR_CONSTRUCTION_CODE
+
+#endif   //BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+}} //namespace boost::container
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_USES_ALLOCATOR_CONSTRUCTION_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/uses_allocator_fwd.hpp

@@ -15,9 +15,7 @@
 #include <boost/container/detail/std_fwd.hpp>
 
 //! \file
-//!   This header forward declares boost::container::constructible_with_allocator_prefix,
-//!   boost::container::constructible_with_allocator_suffix and
-//!   boost::container::uses_allocator. Also defines the following types:
+//!   This header forward declares boost::container::uses_allocator. Also defines the following types:
 
 namespace boost {
 namespace container {