passenger 6.0.19 → 6.0.21

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

@@ -2,7 +2,7 @@
 // deferred.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2022 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)
@@ -16,12 +16,6 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-
-#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
-    && defined(BOOST_ASIO_HAS_DECLTYPE) \
-    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
-  || defined(GENERATING_DOCUMENTATION)
-
 #include <tuple>
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
@@ -39,23 +33,27 @@ struct is_deferred : false_type
 {
 };
 
+/// Helper type to wrap multiple completion signatures.
+template <typename... Signatures>
+struct deferred_signatures
+{
+};
+
 namespace detail {
 
-// Helper trait for getting the completion signature of the tail in a sequence
+// Helper trait for getting the completion signatures of the tail in a sequence
 // when invoked with the specified arguments.
 
-template <typename HeadSignature, typename Tail>
-struct deferred_sequence_signature;
+template <typename Tail, typename... Signatures>
+struct deferred_sequence_signatures;
 
-template <typename R, typename... Args, typename Tail>
-struct deferred_sequence_signature<R(Args...), Tail>
+template <typename Tail, typename R, typename... Args, typename... Signatures>
+struct deferred_sequence_signatures<Tail, R(Args...), Signatures...>
+  : completion_signature_of<decltype(declval<Tail>()(declval<Args>()...))>
 {
   static_assert(
       !is_same<decltype(declval<Tail>()(declval<Args>()...)), void>::value,
       "deferred functions must produce a deferred return type");
-
-  typedef typename completion_signature_of<
-    decltype(declval<Tail>()(declval<Args>()...))>::type type;
 };
 
 // Completion handler for the head component of a deferred sequence.
@@ -64,19 +62,18 @@ class deferred_sequence_handler
 {
 public:
   template <typename H, typename T>
-  explicit deferred_sequence_handler(
-      BOOST_ASIO_MOVE_ARG(H) handler, BOOST_ASIO_MOVE_ARG(T) tail)
-    : handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
-      tail_(BOOST_ASIO_MOVE_CAST(T)(tail))
+  explicit deferred_sequence_handler(H&& handler, T&& tail)
+    : handler_(static_cast<H&&>(handler)),
+      tail_(static_cast<T&&>(tail))
   {
   }
 
   template <typename... Args>
-  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  void operator()(Args&&... args)
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Tail)(tail_)(
-        BOOST_ASIO_MOVE_CAST(Args)(args)...)(
-          BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_));
+    static_cast<Tail&&>(tail_)(
+        static_cast<Args&&>(args)...)(
+          static_cast<Handler&&>(handler_));
   }
 
 //private:
@@ -84,6 +81,76 @@ public:
   Tail tail_;
 };
 
+template <typename Head, typename Tail, typename... Signatures>
+class deferred_sequence_base
+{
+private:
+  struct initiate
+  {
+    template <typename Handler>
+    void operator()(Handler&& handler, Head head, Tail&& tail)
+    {
+      static_cast<Head&&>(head)(
+          deferred_sequence_handler<decay_t<Handler>, decay_t<Tail>>(
+            static_cast<Handler&&>(handler), static_cast<Tail&&>(tail)));
+    }
+  };
+
+  Head head_;
+  Tail tail_;
+
+public:
+  template <typename H, typename T>
+  constexpr explicit deferred_sequence_base(H&& head, T&& tail)
+    : head_(static_cast<H&&>(head)),
+      tail_(static_cast<T&&>(tail))
+  {
+  }
+
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(CompletionToken&& token) &&
+    -> decltype(
+      async_initiate<CompletionToken, Signatures...>(
+        initiate(), token, static_cast<Head&&>(this->head_),
+        static_cast<Tail&&>(this->tail_)))
+  {
+    return async_initiate<CompletionToken, Signatures...>(initiate(),
+        token, static_cast<Head&&>(head_), static_cast<Tail&&>(tail_));
+  }
+
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(CompletionToken&& token) const &
+    -> decltype(
+      async_initiate<CompletionToken, Signatures...>(
+        initiate(), token, this->head_, this->tail_))
+  {
+    return async_initiate<CompletionToken, Signatures...>(
+        initiate(), token, head_, tail_);
+  }
+};
+
+// Two-step application of variadic Signatures to determine correct base type.
+
+template <typename Head, typename Tail>
+struct deferred_sequence_types
+{
+  template <typename... Signatures>
+  struct op1
+  {
+    typedef deferred_sequence_base<Head, Tail, Signatures...> type;
+  };
+
+  template <typename... Signatures>
+  struct op2
+  {
+    typedef typename deferred_sequence_signatures<Tail, Signatures...>::template
+      apply<op1>::type::type type;
+  };
+
+  typedef typename completion_signature_of<Head>::template
+    apply<op2>::type::type base;
+};
+
 } // namespace detail
 
 /// Used to represent an empty deferred action.
@@ -91,17 +158,15 @@ struct deferred_noop
 {
   /// No effect.
   template <typename... Args>
-  void operator()(BOOST_ASIO_MOVE_ARG(Args)...) BOOST_ASIO_RVALUE_REF_QUAL
+  void operator()(Args&&...) &&
   {
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   /// No effect.
   template <typename... Args>
-  void operator()(BOOST_ASIO_MOVE_ARG(Args)...) const &
+  void operator()(Args&&...) const &
   {
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 };
 
 #if !defined(GENERATING_DOCUMENTATION)
@@ -122,9 +187,8 @@ class deferred_function
 public:
   /// Constructor. 
   template <typename F>
-  BOOST_ASIO_CONSTEXPR explicit deferred_function(
-      deferred_init_tag, BOOST_ASIO_MOVE_ARG(F) function)
-    : function_(BOOST_ASIO_MOVE_CAST(F)(function))
+  constexpr explicit deferred_function(deferred_init_tag, F&& function)
+    : function_(static_cast<F&&>(function))
   {
   }
 
@@ -133,30 +197,24 @@ public:
 
 public:
   template <typename... Args>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(Args)... args) BOOST_ASIO_RVALUE_REF_QUAL
+  auto operator()(Args&&... args) &&
     -> decltype(
-        BOOST_ASIO_MOVE_CAST(Function)(this->function_)(
-          BOOST_ASIO_MOVE_CAST(Args)(args)...))
+      static_cast<Function&&>(this->function_)(static_cast<Args&&>(args)...))
   {
-    return BOOST_ASIO_MOVE_CAST(Function)(function_)(
-        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return static_cast<Function&&>(function_)(static_cast<Args&&>(args)...);
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   template <typename... Args>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(Args)... args) const &
-    -> decltype(Function(function_)(BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  auto operator()(Args&&... args) const &
+    -> decltype(Function(function_)(static_cast<Args&&>(args)...))
   {
-    return Function(function_)(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return Function(function_)(static_cast<Args&&>(args)...);
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 };
 
 #if !defined(GENERATING_DOCUMENTATION)
 template <typename Function>
-struct is_deferred<deferred_function<Function> > : true_type
+struct is_deferred<deferred_function<Function>> : true_type
 {
 };
 #endif // !defined(GENERATING_DOCUMENTATION)
@@ -171,85 +229,72 @@ private:
   struct initiate
   {
     template <typename Handler, typename... V>
-    void operator()(Handler handler, BOOST_ASIO_MOVE_ARG(V)... values)
+    void operator()(Handler handler, V&&... values)
     {
-      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(
-          BOOST_ASIO_MOVE_CAST(V)(values)...);
+      static_cast<Handler&&>(handler)(static_cast<V&&>(values)...);
     }
   };
 
   template <typename CompletionToken, std::size_t... I>
-  auto invoke_helper(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
-      detail::index_sequence<I...>)
+  auto invoke_helper(CompletionToken&& token, detail::index_sequence<I...>)
     -> decltype(
-        boost::asio::async_initiate<CompletionToken, void(Values...)>(
-          initiate(), token,
-          std::get<I>(
-            BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(this->values_))...))
+      async_initiate<CompletionToken, void(Values...)>(initiate(), token,
+        std::get<I>(static_cast<std::tuple<Values...>&&>(this->values_))...))
   {
-    return boost::asio::async_initiate<CompletionToken, void(Values...)>(
-        initiate(), token,
-        std::get<I>(BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values_))...);
+    return async_initiate<CompletionToken, void(Values...)>(initiate(), token,
+        std::get<I>(static_cast<std::tuple<Values...>&&>(values_))...);
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   template <typename CompletionToken, std::size_t... I>
-  auto const_invoke_helper(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+  auto const_invoke_helper(CompletionToken&& token,
       detail::index_sequence<I...>)
     -> decltype(
-        boost::asio::async_initiate<CompletionToken, void(Values...)>(
-          initiate(), token, std::get<I>(values_)...))
+      async_initiate<CompletionToken, void(Values...)>(
+        initiate(), token, std::get<I>(values_)...))
   {
-    return boost::asio::async_initiate<CompletionToken, void(Values...)>(
+    return async_initiate<CompletionToken, void(Values...)>(
         initiate(), token, std::get<I>(values_)...);
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
 public:
   /// Construct a deferred asynchronous operation from the arguments to an
   /// initiation function object.
   template <typename... V>
-  BOOST_ASIO_CONSTEXPR explicit deferred_values(
-      deferred_init_tag, BOOST_ASIO_MOVE_ARG(V)... values)
-    : values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  constexpr explicit deferred_values(
+      deferred_init_tag, V&&... values)
+    : values_(static_cast<V&&>(values)...)
   {
   }
 
   /// Initiate the deferred operation using the supplied completion token.
   template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+  auto operator()(CompletionToken&& token) &&
     -> decltype(
-        this->invoke_helper(
-          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
-          detail::index_sequence_for<Values...>()))
+      this->invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<Values...>()))
   {
     return this->invoke_helper(
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        static_cast<CompletionToken&&>(token),
         detail::index_sequence_for<Values...>());
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+  auto operator()(CompletionToken&& token) const &
     -> decltype(
-        this->const_invoke_helper(
-          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
-          detail::index_sequence_for<Values...>()))
+      this->const_invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<Values...>()))
   {
     return this->const_invoke_helper(
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        static_cast<CompletionToken&&>(token),
         detail::index_sequence_for<Values...>());
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 };
 
 #if !defined(GENERATING_DOCUMENTATION)
 template <typename... Values>
-struct is_deferred<deferred_values<Values...> > : true_type
+struct is_deferred<deferred_values<Values...>> : true_type
 {
 };
 #endif // !defined(GENERATING_DOCUMENTATION)
@@ -259,164 +304,182 @@ template <typename Signature, typename Initiation, typename... InitArgs>
 class BOOST_ASIO_NODISCARD deferred_async_operation
 {
 private:
-  typedef typename decay<Initiation>::type initiation_t;
+  typedef decay_t<Initiation> initiation_t;
   initiation_t initiation_;
-  typedef std::tuple<typename decay<InitArgs>::type...> init_args_t;
+  typedef std::tuple<decay_t<InitArgs>...> init_args_t;
   init_args_t init_args_;
 
   template <typename CompletionToken, std::size_t... I>
-  auto invoke_helper(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
-      detail::index_sequence<I...>)
+  auto invoke_helper(CompletionToken&& token, detail::index_sequence<I...>)
     -> decltype(
-        boost::asio::async_initiate<CompletionToken, Signature>(
-          BOOST_ASIO_MOVE_CAST(initiation_t)(initiation_), token,
-          std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...))
+      async_initiate<CompletionToken, Signature>(
+        static_cast<initiation_t&&>(initiation_), token,
+        std::get<I>(static_cast<init_args_t&&>(init_args_))...))
   {
-    return boost::asio::async_initiate<CompletionToken, Signature>(
-        BOOST_ASIO_MOVE_CAST(initiation_t)(initiation_), token,
-        std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...);
+    return async_initiate<CompletionToken, Signature>(
+        static_cast<initiation_t&&>(initiation_), token,
+        std::get<I>(static_cast<init_args_t&&>(init_args_))...);
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   template <typename CompletionToken, std::size_t... I>
-  auto const_invoke_helper(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+  auto const_invoke_helper(CompletionToken&& token,
       detail::index_sequence<I...>) const &
     -> decltype(
-        boost::asio::async_initiate<CompletionToken, Signature>(
-          initiation_t(initiation_), token, std::get<I>(init_args_)...))
-    {
-    return boost::asio::async_initiate<CompletionToken, Signature>(
+      async_initiate<CompletionToken, Signature>(
+        initiation_t(initiation_), token, std::get<I>(init_args_)...))
+  {
+    return async_initiate<CompletionToken, Signature>(
         initiation_t(initiation_), token, std::get<I>(init_args_)...);
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
 public:
   /// Construct a deferred asynchronous operation from the arguments to an
   /// initiation function object.
   template <typename I, typename... A>
-  BOOST_ASIO_CONSTEXPR explicit deferred_async_operation(
-      deferred_init_tag, BOOST_ASIO_MOVE_ARG(I) initiation,
-      BOOST_ASIO_MOVE_ARG(A)... init_args)
-    : initiation_(BOOST_ASIO_MOVE_CAST(I)(initiation)),
-      init_args_(BOOST_ASIO_MOVE_CAST(A)(init_args)...)
+  constexpr explicit deferred_async_operation(
+      deferred_init_tag, I&& initiation, A&&... init_args)
+    : initiation_(static_cast<I&&>(initiation)),
+      init_args_(static_cast<A&&>(init_args)...)
   {
   }
 
   /// Initiate the asynchronous operation using the supplied completion token.
   template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+  auto operator()(CompletionToken&& token) &&
     -> decltype(
-        this->invoke_helper(
-          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
-          detail::index_sequence_for<InitArgs...>()))
+      this->invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<InitArgs...>()))
   {
     return this->invoke_helper(
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        static_cast<CompletionToken&&>(token),
         detail::index_sequence_for<InitArgs...>());
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+  auto operator()(CompletionToken&& token) const &
     -> decltype(
-        this->const_invoke_helper(
-          BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
-          detail::index_sequence_for<InitArgs...>()))
+      this->const_invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<InitArgs...>()))
   {
     return this->const_invoke_helper(
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        static_cast<CompletionToken&&>(token),
         detail::index_sequence_for<InitArgs...>());
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 };
 
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename Signature, typename Initiation, typename... InitArgs>
-struct is_deferred<
-    deferred_async_operation<Signature, Initiation, InitArgs...> > : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Defines a link between two consecutive operations in a sequence.
-template <typename Head, typename Tail>
-class BOOST_ASIO_NODISCARD deferred_sequence
+/// Encapsulates a deferred asynchronous operation thas has multiple completion
+/// signatures.
+template <typename... Signatures, typename Initiation, typename... InitArgs>
+class BOOST_ASIO_NODISCARD deferred_async_operation<
+    deferred_signatures<Signatures...>, Initiation, InitArgs...>
 {
 private:
-  typedef typename detail::deferred_sequence_signature<
-    typename completion_signature_of<Head>::type, Tail>::type
-      signature;
+  typedef decay_t<Initiation> initiation_t;
+  initiation_t initiation_;
+  typedef std::tuple<decay_t<InitArgs>...> init_args_t;
+  init_args_t init_args_;
 
-  struct initiate
+  template <typename CompletionToken, std::size_t... I>
+  auto invoke_helper(CompletionToken&& token, detail::index_sequence<I...>)
+    -> decltype(
+      async_initiate<CompletionToken, Signatures...>(
+        static_cast<initiation_t&&>(initiation_), token,
+        std::get<I>(static_cast<init_args_t&&>(init_args_))...))
   {
-    template <typename Handler>
-    void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler,
-        Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
-    {
-      BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
-          detail::deferred_sequence_handler<
-            typename decay<Handler>::type,
-            typename decay<Tail>::type>(
-              BOOST_ASIO_MOVE_CAST(Handler)(handler),
-              BOOST_ASIO_MOVE_CAST(Tail)(tail)));
-    }
-  };
+    return async_initiate<CompletionToken, Signatures...>(
+        static_cast<initiation_t&&>(initiation_), token,
+        std::get<I>(static_cast<init_args_t&&>(init_args_))...);
+  }
 
-  Head head_;
-  Tail tail_;
+  template <typename CompletionToken, std::size_t... I>
+  auto const_invoke_helper(CompletionToken&& token,
+      detail::index_sequence<I...>) const &
+    -> decltype(
+      async_initiate<CompletionToken, Signatures...>(
+        initiation_t(initiation_), token, std::get<I>(init_args_)...))
+  {
+    return async_initiate<CompletionToken, Signatures...>(
+        initiation_t(initiation_), token, std::get<I>(init_args_)...);
+  }
 
 public:
-  template <typename H, typename T>
-  BOOST_ASIO_CONSTEXPR explicit deferred_sequence(deferred_init_tag,
-      BOOST_ASIO_MOVE_ARG(H) head, BOOST_ASIO_MOVE_ARG(T) tail)
-    : head_(BOOST_ASIO_MOVE_CAST(H)(head)),
-      tail_(BOOST_ASIO_MOVE_CAST(T)(tail))
+  /// Construct a deferred asynchronous operation from the arguments to an
+  /// initiation function object.
+  template <typename I, typename... A>
+  constexpr explicit deferred_async_operation(
+      deferred_init_tag, I&& initiation, A&&... init_args)
+    : initiation_(static_cast<I&&>(initiation)),
+      init_args_(static_cast<A&&>(init_args)...)
   {
   }
 
-  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+  /// Initiate the asynchronous operation using the supplied completion token.
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(CompletionToken&& token) &&
     -> decltype(
-        boost::asio::async_initiate<CompletionToken, signature>(
-          declval<initiate>(), token,
-          BOOST_ASIO_MOVE_OR_LVALUE(Head)(this->head_),
-          BOOST_ASIO_MOVE_OR_LVALUE(Tail)(this->tail_)))
+      this->invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<InitArgs...>()))
   {
-    return boost::asio::async_initiate<CompletionToken, signature>(
-        initiate(), token,
-        BOOST_ASIO_MOVE_OR_LVALUE(Head)(head_),
-        BOOST_ASIO_MOVE_OR_LVALUE(Tail)(tail_));
+    return this->invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<InitArgs...>());
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  auto operator()(
-      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
+  auto operator()(CompletionToken&& token) const &
     -> decltype(
-        boost::asio::async_initiate<CompletionToken, signature>(
-          initiate(), token, head_, tail_))
+      this->const_invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<InitArgs...>()))
+  {
+    return this->const_invoke_helper(
+        static_cast<CompletionToken&&>(token),
+        detail::index_sequence_for<InitArgs...>());
+  }
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Signature, typename Initiation, typename... InitArgs>
+struct is_deferred<
+    deferred_async_operation<Signature, Initiation, InitArgs...>> : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Defines a link between two consecutive operations in a sequence.
+template <typename Head, typename Tail>
+class BOOST_ASIO_NODISCARD deferred_sequence :
+  public detail::deferred_sequence_types<Head, Tail>::base
+{
+public:
+  template <typename H, typename T>
+  constexpr explicit deferred_sequence(deferred_init_tag, H&& head, T&& tail)
+    : detail::deferred_sequence_types<Head, Tail>::base(
+        static_cast<H&&>(head), static_cast<T&&>(tail))
   {
-    return boost::asio::async_initiate<CompletionToken, signature>(
-        initiate(), token, head_, tail_);
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+#if defined(GENERATING_DOCUMENTATION)
+  template <typename CompletionToken>
+  auto operator()(CompletionToken&& token) &&;
+
+  template <typename CompletionToken>
+  auto operator()(CompletionToken&& token) const &;
+#endif // defined(GENERATING_DOCUMENTATION)
 };
 
 #if !defined(GENERATING_DOCUMENTATION)
 template <typename Head, typename Tail>
-struct is_deferred<deferred_sequence<Head, Tail> > : true_type
+struct is_deferred<deferred_sequence<Head, Tail>> : true_type
 {
 };
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 /// Used to represent a deferred conditional branch.
-template <typename OnTrue = deferred_noop,
-    typename OnFalse = deferred_noop>
+template <typename OnTrue = deferred_noop, typename OnFalse = deferred_noop>
 class BOOST_ASIO_NODISCARD deferred_conditional
 {
 private:
@@ -424,10 +487,9 @@ private:
 
   // Helper constructor.
   template <typename T, typename F>
-  explicit deferred_conditional(bool b, BOOST_ASIO_MOVE_ARG(T) on_true,
-      BOOST_ASIO_MOVE_ARG(F) on_false)
-    : on_true_(BOOST_ASIO_MOVE_CAST(T)(on_true)),
-      on_false_(BOOST_ASIO_MOVE_CAST(F)(on_false)),
+  explicit deferred_conditional(bool b, T&& on_true, F&& on_false)
+    : on_true_(static_cast<T&&>(on_true)),
+      on_false_(static_cast<F&&>(on_false)),
       bool_(b)
   {
   }
@@ -439,94 +501,88 @@ private:
 public:
   /// Construct a deferred conditional with the value to determine which branch
   /// will be executed.
-  BOOST_ASIO_CONSTEXPR explicit deferred_conditional(bool b)
+  constexpr explicit deferred_conditional(bool b)
     : on_true_(),
       on_false_(),
       bool_(b)
   {
   }
 
-  /// Invoke the conditional branch bsaed on the stored alue.
+  /// Invoke the conditional branch bsaed on the stored value.
   template <typename... Args>
-  auto operator()(BOOST_ASIO_MOVE_ARG(Args)... args) BOOST_ASIO_RVALUE_REF_QUAL
-    -> decltype(
-        BOOST_ASIO_MOVE_OR_LVALUE(OnTrue)(on_true_)(
-          BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  auto operator()(Args&&... args) &&
+    -> decltype(static_cast<OnTrue&&>(on_true_)(static_cast<Args&&>(args)...))
   {
     if (bool_)
     {
-      return BOOST_ASIO_MOVE_OR_LVALUE(OnTrue)(on_true_)(
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      return static_cast<OnTrue&&>(on_true_)(static_cast<Args&&>(args)...);
     }
     else
     {
-      return BOOST_ASIO_MOVE_OR_LVALUE(OnFalse)(on_false_)(
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      return static_cast<OnFalse&&>(on_false_)(static_cast<Args&&>(args)...);
     }
   }
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
   template <typename... Args>
-  auto operator()(BOOST_ASIO_MOVE_ARG(Args)... args) const &
-    -> decltype(on_true_(BOOST_ASIO_MOVE_CAST(Args)(args)...))
+  auto operator()(Args&&... args) const &
+    -> decltype(on_true_(static_cast<Args&&>(args)...))
   {
     if (bool_)
     {
-      return on_true_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      return on_true_(static_cast<Args&&>(args)...);
     }
     else
     {
-      return on_false_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      return on_false_(static_cast<Args&&>(args)...);
     }
   }
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
   /// Set the true branch of the conditional.
   template <typename T>
   deferred_conditional<T, OnFalse> then(T on_true,
-      typename constraint<
+      constraint_t<
         is_deferred<T>::value
-      >::type* = 0,
-      typename constraint<
+      >* = 0,
+      constraint_t<
         is_same<
-          typename conditional<true, OnTrue, T>::type,
+          conditional_t<true, OnTrue, T>,
           deferred_noop
         >::value
-      >::type* = 0) BOOST_ASIO_RVALUE_REF_QUAL
+      >* = 0) &&
   {
     return deferred_conditional<T, OnFalse>(
-        bool_, BOOST_ASIO_MOVE_CAST(T)(on_true),
-        BOOST_ASIO_MOVE_CAST(OnFalse)(on_false_));
+        bool_, static_cast<T&&>(on_true),
+        static_cast<OnFalse&&>(on_false_));
   }
 
   /// Set the false branch of the conditional.
   template <typename T>
   deferred_conditional<OnTrue, T> otherwise(T on_false,
-      typename constraint<
+      constraint_t<
         is_deferred<T>::value
-      >::type* = 0,
-      typename constraint<
+      >* = 0,
+      constraint_t<
         !is_same<
-          typename conditional<true, OnTrue, T>::type,
+          conditional_t<true, OnTrue, T>,
           deferred_noop
         >::value
-      >::type* = 0,
-      typename constraint<
+      >* = 0,
+      constraint_t<
         is_same<
-          typename conditional<true, OnFalse, T>::type,
+          conditional_t<true, OnFalse, T>,
           deferred_noop
         >::value
-      >::type* = 0) BOOST_ASIO_RVALUE_REF_QUAL
+      >* = 0) &&
   {
     return deferred_conditional<OnTrue, T>(
-        bool_, BOOST_ASIO_MOVE_CAST(OnTrue)(on_true_),
-        BOOST_ASIO_MOVE_CAST(T)(on_false));
+        bool_, static_cast<OnTrue&&>(on_true_),
+        static_cast<T&&>(on_false));
   }
 };
 
 #if !defined(GENERATING_DOCUMENTATION)
 template <typename OnTrue, typename OnFalse>
-struct is_deferred<deferred_conditional<OnTrue, OnFalse> > : true_type
+struct is_deferred<deferred_conditional<OnTrue, OnFalse>> : true_type
 {
 };
 #endif // !defined(GENERATING_DOCUMENTATION)
@@ -551,7 +607,7 @@ class deferred_t
 {
 public:
   /// Default constructor.
-  BOOST_ASIO_CONSTEXPR deferred_t()
+  constexpr deferred_t()
   {
   }
 
@@ -566,13 +622,13 @@ public:
     /// Construct the adapted executor from the inner executor type.
     template <typename InnerExecutor1>
     executor_with_default(const InnerExecutor1& ex,
-        typename constraint<
-          conditional<
+        constraint_t<
+          conditional_t<
             !is_same<InnerExecutor1, executor_with_default>::value,
             is_convertible<InnerExecutor1, InnerExecutor>,
             false_type
-          >::type::value
-        >::type = 0) BOOST_ASIO_NOEXCEPT
+          >::value
+        > = 0) noexcept
       : InnerExecutor(ex)
     {
     }
@@ -580,59 +636,54 @@ public:
 
   /// Type alias to adapt an I/O object to use @c deferred_t as its
   /// default completion token type.
-#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
-  || defined(GENERATING_DOCUMENTATION)
   template <typename T>
   using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type> >::other;
-#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
-       //   || defined(GENERATING_DOCUMENTATION)
+      executor_with_default<typename T::executor_type>>::other;
 
   /// Function helper to adapt an I/O object to use @c deferred_t as its
   /// default completion token type.
   template <typename T>
-  static typename decay<T>::type::template rebind_executor<
-      executor_with_default<typename decay<T>::type::executor_type>
+  static typename decay_t<T>::template rebind_executor<
+      executor_with_default<typename decay_t<T>::executor_type>
     >::other
-  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  as_default_on(T&& object)
   {
-    return typename decay<T>::type::template rebind_executor<
-        executor_with_default<typename decay<T>::type::executor_type>
-      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+    return typename decay_t<T>::template rebind_executor<
+        executor_with_default<typename decay_t<T>::executor_type>
+      >::other(static_cast<T&&>(object));
   }
 
   /// Creates a new deferred from a function.
   template <typename Function>
-  typename constraint<
-    !is_deferred<typename decay<Function>::type>::value,
-    deferred_function<typename decay<Function>::type>
-  >::type operator()(BOOST_ASIO_MOVE_ARG(Function) function) const
+  constraint_t<
+    !is_deferred<decay_t<Function>>::value,
+    deferred_function<decay_t<Function>>
+  > operator()(Function&& function) const
   {
-    return deferred_function<typename decay<Function>::type>(
-        deferred_init_tag{}, BOOST_ASIO_MOVE_CAST(Function)(function));
+    return deferred_function<decay_t<Function>>(
+        deferred_init_tag{}, static_cast<Function&&>(function));
   }
 
   /// Passes through anything that is already deferred.
   template <typename T>
-  typename constraint<
-    is_deferred<typename decay<T>::type>::value,
-    typename decay<T>::type
-  >::type operator()(BOOST_ASIO_MOVE_ARG(T) t) const
+  constraint_t<
+    is_deferred<decay_t<T>>::value,
+    decay_t<T>
+  > operator()(T&& t) const
   {
-    return BOOST_ASIO_MOVE_CAST(T)(t);
+    return static_cast<T&&>(t);
   }
 
   /// Returns a deferred operation that returns the provided values.
   template <typename... Args>
-  static BOOST_ASIO_CONSTEXPR deferred_values<typename decay<Args>::type...>
-  values(BOOST_ASIO_MOVE_ARG(Args)... args)
+  static constexpr deferred_values<decay_t<Args>...> values(Args&&... args)
   {
-    return deferred_values<typename decay<Args>::type...>(
-        deferred_init_tag{}, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return deferred_values<decay_t<Args>...>(
+        deferred_init_tag{}, static_cast<Args&&>(args)...);
   }
 
   /// Creates a conditional object for branching deferred operations.
-  static BOOST_ASIO_CONSTEXPR deferred_conditional<> when(bool b)
+  static constexpr deferred_conditional<> when(bool b)
   {
     return deferred_conditional<>(b);
   }
@@ -640,15 +691,13 @@ public:
 
 /// Pipe operator used to chain deferred operations.
 template <typename Head, typename Tail>
-inline auto operator|(Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
-  -> typename constraint<
+inline auto operator|(Head head, Tail&& tail)
+  -> constraint_t<
       is_deferred<Head>::value,
-      decltype(BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
-            BOOST_ASIO_MOVE_CAST(Tail)(tail)))
-    >::type
+      decltype(static_cast<Head&&>(head)(static_cast<Tail&&>(tail)))
+    >
 {
-  return BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
-      BOOST_ASIO_MOVE_CAST(Tail)(tail));
+  return static_cast<Head&&>(head)(static_cast<Tail&&>(tail));
 }
 
 /// A @ref completion_token object used to specify that an asynchronous
@@ -656,11 +705,7 @@ inline auto operator|(Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
 /**
  * See the documentation for boost::asio::deferred_t for a usage example.
  */
-#if defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
 constexpr deferred_t deferred;
-#elif defined(BOOST_ASIO_MSVC)
-__declspec(selectany) deferred_t deferred;
-#endif
 
 } // namespace asio
 } // namespace boost
@@ -669,9 +714,4 @@ __declspec(selectany) deferred_t deferred;
 
 #include <boost/asio/impl/deferred.hpp>
 
-#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
-       //     && defined(BOOST_ASIO_HAS_DECLTYPE))
-       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
-       //   || defined(GENERATING_DOCUMENTATION)
-
 #endif // BOOST_ASIO_DEFERRED_HPP