passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/asio/bind_allocator.hpp

@@ -2,7 +2,7 @@
 // bind_allocator.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -17,7 +17,6 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/type_traits.hpp>
-#include <boost/asio/detail/variadic_templates.hpp>
 #include <boost/asio/associated_allocator.hpp>
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
@@ -38,8 +37,7 @@ protected:
 };
 
 template <typename T>
-struct allocator_binder_result_type<T,
-  typename void_type<typename T::result_type>::type>
+struct allocator_binder_result_type<T, void_t<typename T::result_type>>
 {
   typedef typename T::result_type result_type;
 protected:
@@ -100,8 +98,7 @@ template <typename T, typename = void>
 struct allocator_binder_argument_type {};
 
 template <typename T>
-struct allocator_binder_argument_type<T,
-  typename void_type<typename T::argument_type>::type>
+struct allocator_binder_argument_type<T, void_t<typename T::argument_type>>
 {
   typedef typename T::argument_type argument_type;
 };
@@ -126,7 +123,7 @@ struct allocator_binder_argument_types {};
 
 template <typename T>
 struct allocator_binder_argument_types<T,
-  typename void_type<typename T::first_argument_type>::type>
+    void_t<typename T::first_argument_type>>
 {
   typedef typename T::first_argument_type first_argument_type;
   typedef typename T::second_argument_type second_argument_type;
@@ -146,21 +143,6 @@ struct allocator_binder_argument_type<R(&)(A1, A2)>
   typedef A2 second_argument_type;
 };
 
-// Helper to enable SFINAE on zero-argument operator() below.
-
-template <typename T, typename = void>
-struct allocator_binder_result_of0
-{
-  typedef void type;
-};
-
-template <typename T>
-struct allocator_binder_result_of0<T,
-  typename void_type<typename result_of<T()>::type>::type>
-{
-  typedef typename result_of<T()>::type type;
-};
-
 } // namespace detail
 
 /// A call wrapper type to bind an allocator of type @c Allocator
@@ -248,10 +230,9 @@ public:
    * @c U.
    */
   template <typename U>
-  allocator_binder(const allocator_type& s,
-      BOOST_ASIO_MOVE_ARG(U) u)
+  allocator_binder(const allocator_type& s, U&& u)
     : allocator_(s),
-      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+      target_(static_cast<U&&>(u))
   {
   }
 
@@ -263,8 +244,7 @@ public:
   }
 
   /// Construct a copy, but specify a different allocator.
-  allocator_binder(const allocator_type& s,
-      const allocator_binder& other)
+  allocator_binder(const allocator_type& s, const allocator_binder& other)
     : allocator_(s),
       target_(other.get())
   {
@@ -277,8 +257,9 @@ public:
    * constructible from type @c U.
    */
   template <typename U, typename OtherAllocator>
-  allocator_binder(
-      const allocator_binder<U, OtherAllocator>& other)
+  allocator_binder(const allocator_binder<U, OtherAllocator>& other,
+      constraint_t<is_constructible<Allocator, OtherAllocator>::value> = 0,
+      constraint_t<is_constructible<T, U>::value> = 0)
     : allocator_(other.get_allocator()),
       target_(other.get())
   {
@@ -292,19 +273,18 @@ public:
    */
   template <typename U, typename OtherAllocator>
   allocator_binder(const allocator_type& s,
-      const allocator_binder<U, OtherAllocator>& other)
+      const allocator_binder<U, OtherAllocator>& other,
+      constraint_t<is_constructible<T, U>::value> = 0)
     : allocator_(s),
       target_(other.get())
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Move constructor.
   allocator_binder(allocator_binder&& other)
-    : allocator_(BOOST_ASIO_MOVE_CAST(allocator_type)(
+    : allocator_(static_cast<allocator_type&&>(
           other.get_allocator())),
-      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+      target_(static_cast<T&&>(other.get()))
   {
   }
 
@@ -312,17 +292,19 @@ public:
   allocator_binder(const allocator_type& s,
       allocator_binder&& other)
     : allocator_(s),
-      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+      target_(static_cast<T&&>(other.get()))
   {
   }
 
   /// Move construct from a different allocator wrapper type.
   template <typename U, typename OtherAllocator>
   allocator_binder(
-      allocator_binder<U, OtherAllocator>&& other)
-    : allocator_(BOOST_ASIO_MOVE_CAST(OtherAllocator)(
+      allocator_binder<U, OtherAllocator>&& other,
+      constraint_t<is_constructible<Allocator, OtherAllocator>::value> = 0,
+      constraint_t<is_constructible<T, U>::value> = 0)
+    : allocator_(static_cast<OtherAllocator&&>(
           other.get_allocator())),
-      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+      target_(static_cast<U&&>(other.get()))
   {
   }
 
@@ -330,126 +312,50 @@ public:
   /// specify a different allocator.
   template <typename U, typename OtherAllocator>
   allocator_binder(const allocator_type& s,
-      allocator_binder<U, OtherAllocator>&& other)
+      allocator_binder<U, OtherAllocator>&& other,
+      constraint_t<is_constructible<T, U>::value> = 0)
     : allocator_(s),
-      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+      target_(static_cast<U&&>(other.get()))
   {
   }
 
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Destructor.
   ~allocator_binder()
   {
   }
 
   /// Obtain a reference to the target object.
-  target_type& get() BOOST_ASIO_NOEXCEPT
+  target_type& get() noexcept
   {
     return target_;
   }
 
   /// Obtain a reference to the target object.
-  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  const target_type& get() const noexcept
   {
     return target_;
   }
 
   /// Obtain the associated allocator.
-  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  allocator_type get_allocator() const noexcept
   {
     return allocator_;
   }
 
-#if defined(GENERATING_DOCUMENTATION)
-
-  template <typename... Args> auto operator()(Args&& ...);
-  template <typename... Args> auto operator()(Args&& ...) const;
-
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
   /// Forwarding function call operator.
   template <typename... Args>
-  typename result_of<T(Args...)>::type operator()(
-      BOOST_ASIO_MOVE_ARG(Args)... args)
+  result_of_t<T(Args...)> operator()(Args&&... args)
   {
-    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return target_(static_cast<Args&&>(args)...);
   }
 
   /// Forwarding function call operator.
   template <typename... Args>
-  typename result_of<T(Args...)>::type operator()(
-      BOOST_ASIO_MOVE_ARG(Args)... args) const
-  {
-    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
-  }
-
-#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
-
-  typename detail::allocator_binder_result_of0<T>::type operator()()
-  {
-    return target_();
-  }
-
-  typename detail::allocator_binder_result_of0<T>::type
-  operator()() const
-  {
-    return target_();
-  }
-
-#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
-#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
-
-#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
-
-  typedef typename detail::allocator_binder_result_type<
-    T>::result_type_or_void result_type_or_void;
-
-  result_type_or_void operator()()
+  result_of_t<T(Args...)> operator()(Args&&... args) const
   {
-    return target_();
+    return target_(static_cast<Args&&>(args)...);
   }
 
-  result_type_or_void operator()() const
-  {
-    return target_();
-  }
-
-#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  result_type_or_void operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  result_type_or_void operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
-#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
-
-#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
-
 private:
   Allocator allocator_;
   T target_;
@@ -458,20 +364,17 @@ private:
 /// Associate an object of type @c T with an allocator of type
 /// @c Allocator.
 template <typename Allocator, typename T>
-BOOST_ASIO_NODISCARD inline allocator_binder<typename decay<T>::type, Allocator>
-bind_allocator(const Allocator& s, BOOST_ASIO_MOVE_ARG(T) t)
+BOOST_ASIO_NODISCARD inline allocator_binder<decay_t<T>, Allocator>
+bind_allocator(const Allocator& s, T&& t)
 {
-  return allocator_binder<
-    typename decay<T>::type, Allocator>(
-      s, BOOST_ASIO_MOVE_CAST(T)(t));
+  return allocator_binder<decay_t<T>, Allocator>(s, static_cast<T&&>(t));
 }
 
 #if !defined(GENERATING_DOCUMENTATION)
 
 namespace detail {
 
-template <typename TargetAsyncResult,
-  typename Allocator, typename = void>
+template <typename TargetAsyncResult, typename Allocator, typename = void>
 class allocator_binder_completion_handler_async_result
 {
 public:
@@ -483,11 +386,12 @@ public:
 
 template <typename TargetAsyncResult, typename Allocator>
 class allocator_binder_completion_handler_async_result<
-  TargetAsyncResult, Allocator,
-  typename void_type<
-    typename TargetAsyncResult::completion_handler_type
-  >::type>
+    TargetAsyncResult, Allocator,
+    void_t<typename TargetAsyncResult::completion_handler_type>>
 {
+private:
+  TargetAsyncResult target_;
+
 public:
   typedef allocator_binder<
     typename TargetAsyncResult::completion_handler_type, Allocator>
@@ -499,13 +403,10 @@ public:
   {
   }
 
-  typename TargetAsyncResult::return_type get()
+  auto get() -> decltype(target_.get())
   {
     return target_.get();
   }
-
-private:
-  TargetAsyncResult target_;
 };
 
 template <typename TargetAsyncResult, typename = void>
@@ -515,10 +416,7 @@ struct allocator_binder_async_result_return_type
 
 template <typename TargetAsyncResult>
 struct allocator_binder_async_result_return_type<
-  TargetAsyncResult,
-  typename void_type<
-    typename TargetAsyncResult::return_type
-  >::type>
+    TargetAsyncResult, void_type<typename TargetAsyncResult::return_type>>
 {
   typedef typename TargetAsyncResult::return_type return_type;
 };
@@ -528,9 +426,9 @@ struct allocator_binder_async_result_return_type<
 template <typename T, typename Allocator, typename Signature>
 class async_result<allocator_binder<T, Allocator>, Signature> :
   public detail::allocator_binder_completion_handler_async_result<
-    async_result<T, Signature>, Allocator>,
+      async_result<T, Signature>, Allocator>,
   public detail::allocator_binder_async_result_return_type<
-    async_result<T, Signature> >
+      async_result<T, Signature>>
 {
 public:
   explicit async_result(allocator_binder<T, Allocator>& b)
@@ -543,199 +441,82 @@ public:
   struct init_wrapper
   {
     template <typename Init>
-    init_wrapper(const Allocator& allocator, BOOST_ASIO_MOVE_ARG(Init) init)
+    init_wrapper(const Allocator& allocator, Init&& init)
       : allocator_(allocator),
-        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+        initiation_(static_cast<Init&&>(init))
     {
     }
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
     template <typename Handler, typename... Args>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler,
-        BOOST_ASIO_MOVE_ARG(Args)... args)
+    void operator()(Handler&& handler, Args&&... args)
     {
-      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
-          allocator_binder<
-            typename decay<Handler>::type, Allocator>(
-              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      static_cast<Initiation&&>(initiation_)(
+          allocator_binder<decay_t<Handler>, Allocator>(
+              allocator_, static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler,
-        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    void operator()(Handler&& handler, Args&&... args) const
     {
       initiation_(
-          allocator_binder<
-            typename decay<Handler>::type, Allocator>(
-              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+          allocator_binder<decay_t<Handler>, Allocator>(
+              allocator_, static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-    template <typename Handler>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler)
-    {
-      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
-          allocator_binder<
-            typename decay<Handler>::type, Allocator>(
-              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
-    }
-
-    template <typename Handler>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler) const
-    {
-      initiation_(
-          allocator_binder<
-            typename decay<Handler>::type, Allocator>(
-              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
-    }
-
-#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
-    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-    void operator()( \
-        BOOST_ASIO_MOVE_ARG(Handler) handler, \
-        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-    { \
-      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
-          allocator_binder< \
-            typename decay<Handler>::type, Allocator>( \
-              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
-          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-    } \
-    \
-    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-    void operator()( \
-        BOOST_ASIO_MOVE_ARG(Handler) handler, \
-        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
-    { \
-      initiation_( \
-          allocator_binder< \
-            typename decay<Handler>::type, Allocator>( \
-              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
-          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-    } \
-    /**/
-    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
-#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
     Allocator allocator_;
     Initiation initiation_;
   };
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
   template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
-    (async_initiate<T, Signature>(
-        declval<init_wrapper<typename decay<Initiation>::type> >(),
-        declval<RawCompletionToken>().get(),
-        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
-  initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
-      BOOST_ASIO_MOVE_ARG(Args)... args)
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
+    -> decltype(
+      async_initiate<T, Signature>(
+        declval<init_wrapper<decay_t<Initiation>>>(),
+        token.get(), static_cast<Args&&>(args)...))
   {
     return async_initiate<T, Signature>(
-        init_wrapper<typename decay<Initiation>::type>(
-          token.get_allocator(),
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
-        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+        init_wrapper<decay_t<Initiation>>(token.get_allocator(),
+          static_cast<Initiation&&>(initiation)),
+        token.get(), static_cast<Args&&>(args)...);
   }
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-  template <typename Initiation, typename RawCompletionToken>
-  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
-    (async_initiate<T, Signature>(
-        declval<init_wrapper<typename decay<Initiation>::type> >(),
-        declval<RawCompletionToken>().get())))
-  initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
-  {
-    return async_initiate<T, Signature>(
-        init_wrapper<typename decay<Initiation>::type>(
-          token.get_allocator(),
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
-        token.get());
-  }
-
-#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
-  template <typename Initiation, typename RawCompletionToken, \
-      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
-    (async_initiate<T, Signature>( \
-        declval<init_wrapper<typename decay<Initiation>::type> >(), \
-        declval<RawCompletionToken>().get(), \
-        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
-  initiate( \
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return async_initiate<T, Signature>( \
-        init_wrapper<typename decay<Initiation>::type>( \
-          token.get_allocator(), \
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
-        token.get(), BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
-#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 private:
-  async_result(const async_result&) BOOST_ASIO_DELETED;
-  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+  async_result(const async_result&) = delete;
+  async_result& operator=(const async_result&) = delete;
 
   async_result<T, Signature> target_;
 };
 
 template <template <typename, typename> class Associator,
     typename T, typename Allocator, typename DefaultCandidate>
-struct associator<Associator,
-    allocator_binder<T, Allocator>,
-    DefaultCandidate>
+struct associator<Associator, allocator_binder<T, Allocator>, DefaultCandidate>
   : Associator<T, DefaultCandidate>
 {
-  static typename Associator<T, DefaultCandidate>::type
-  get(const allocator_binder<T, Allocator>& b) BOOST_ASIO_NOEXCEPT
+  static typename Associator<T, DefaultCandidate>::type get(
+      const allocator_binder<T, Allocator>& b) noexcept
   {
     return Associator<T, DefaultCandidate>::get(b.get());
   }
 
-  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
-      typename Associator<T, DefaultCandidate>::type)
-  get(const allocator_binder<T, Allocator>& b,
-      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
-      Associator<T, DefaultCandidate>::get(b.get(), c)))
+  static auto get(const allocator_binder<T, Allocator>& b,
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<T, DefaultCandidate>::get(b.get(), c))
   {
     return Associator<T, DefaultCandidate>::get(b.get(), c);
   }
 };
 
 template <typename T, typename Allocator, typename Allocator1>
-struct associated_allocator<
-    allocator_binder<T, Allocator>,
-    Allocator1>
+struct associated_allocator<allocator_binder<T, Allocator>, Allocator1>
 {
   typedef Allocator type;
 
-  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
-      const allocator_binder<T, Allocator>& b,
-      const Allocator1& = Allocator1()) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((b.get_allocator()))
+  static auto get(const allocator_binder<T, Allocator>& b,
+      const Allocator1& = Allocator1()) noexcept
+    -> decltype(b.get_allocator())
   {
     return b.get_allocator();
   }