passenger 6.0.11 → 6.0.12

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/append.hpp

@@ -0,0 +1,219 @@
+//
+// experimental/impl/append.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2021 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)
+//
+
+#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_APPEND_HPP
+#define BOOST_ASIO_IMPL_EXPERIMENTAL_APPEND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Class to adapt a append_t as a completion handler.
+template <typename Handler, typename... Values>
+class append_handler
+{
+public:
+  typedef void result_type;
+
+  template <typename H>
+  append_handler(BOOST_ASIO_MOVE_ARG(H) handler, std::tuple<Values...> values)
+    : handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
+      values_(BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    this->invoke(
+        std::make_index_sequence<sizeof...(Values)>{},
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  template <std::size_t... I, typename... Args>
+  void invoke(std::index_sequence<I...>, BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...,
+        BOOST_ASIO_MOVE_CAST(Values)(std::get<I>(values_))...);
+  }
+
+//private:
+  Handler handler_;
+  std::tuple<Values...> values_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    append_handler<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    append_handler<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    append_handler<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    append_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    append_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Signature, typename... Values>
+struct append_signature;
+
+template <typename R, typename... Args, typename... Values>
+struct append_signature<R(Args...), Values...>
+{
+  typedef R type(typename decay<Args>::type..., Values...);
+};
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename... Values, typename Signature>
+struct async_result<
+    experimental::append_t<CompletionToken, Values...>, Signature>
+  : async_result<CompletionToken,
+      typename experimental::detail::append_signature<
+        Signature, Values...>::type>
+{
+  typedef typename experimental::detail::append_signature<
+      Signature, Values...>::type signature;
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    init_wrapper(Initiation init)
+      : initiation_(BOOST_ASIO_MOVE_CAST(Initiation)(init))
+    {
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        std::tuple<Values...> values,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          experimental::detail::append_handler<
+            typename decay<Handler>::type, Values...>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler),
+              BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    Initiation initiation_;
+  };
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, signature,
+      (async_initiate<CompletionToken, signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<CompletionToken&>(),
+        declval<std::tuple<Values...> >(),
+        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)
+  {
+    return async_initiate<CompletionToken, signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.token_,
+        BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(token.values_),
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::append_handler<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::append_handler<Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_APPEND_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/as_single.hpp

@@ -19,8 +19,7 @@
 
 #include <tuple>
 
-#include <boost/asio/associated_executor.hpp>
-#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
@@ -56,19 +55,21 @@ public:
 
   void operator()()
   {
-    handler_();
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
   }
 
   template <typename Arg>
   void operator()(BOOST_ASIO_MOVE_ARG(Arg) arg)
   {
-    handler_(BOOST_ASIO_MOVE_CAST(Arg)(arg));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Arg)(arg));
   }
 
   template <typename... Args>
   void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
   {
-    handler_(std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
   }
 
 //private:
@@ -206,32 +207,17 @@ struct async_result<experimental::as_single_t<CompletionToken>, Signature>
   }
 };
 
-template <typename Handler, typename Executor>
-struct associated_executor<
-    experimental::detail::as_single_handler<Handler>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::as_single_handler<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(
-      const experimental::detail::as_single_handler<Handler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
-  }
-};
-
-template <typename Handler, typename Allocator>
-struct associated_allocator<
-    experimental::detail::as_single_handler<Handler>, Allocator>
-{
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(
+  static typename Associator<Handler, DefaultCandidate>::type get(
       const experimental::detail::as_single_handler<Handler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/as_tuple.hpp

@@ -0,0 +1,248 @@
+//
+// experimental/impl/as_tuple.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2021 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)
+//
+
+#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_AS_TUPLE_HPP
+#define BOOST_ASIO_IMPL_EXPERIMENTAL_AS_TUPLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <tuple>
+
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Class to adapt a as_tuple_t as a completion handler.
+template <typename Handler>
+class as_tuple_handler
+{
+public:
+  typedef void result_type;
+
+  template <typename CompletionToken>
+  as_tuple_handler(as_tuple_t<CompletionToken> e)
+    : handler_(BOOST_ASIO_MOVE_CAST(CompletionToken)(e.token_))
+  {
+  }
+
+  template <typename RedirectedHandler>
+  as_tuple_handler(BOOST_ASIO_MOVE_ARG(RedirectedHandler) h)
+    : handler_(BOOST_ASIO_MOVE_CAST(RedirectedHandler)(h))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
+  }
+
+//private:
+  Handler handler_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    as_tuple_handler<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    as_tuple_handler<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    as_tuple_handler<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    as_tuple_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    as_tuple_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Signature>
+struct as_tuple_signature;
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...)>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>);
+};
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) &>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) &;
+};
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) &&>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) &&;
+};
+
+# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) noexcept>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) noexcept;
+};
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) & noexcept>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) & noexcept;
+};
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) && noexcept>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) && noexcept;
+};
+
+# endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename... Signatures>
+struct async_result<experimental::as_tuple_t<CompletionToken>, Signatures...>
+  : async_result<CompletionToken,
+      typename experimental::detail::as_tuple_signature<Signatures>::type...>
+{
+  typedef async_result<CompletionToken,
+    typename experimental::detail::as_tuple_signature<Signatures>::type...>
+      base_async_result;
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    init_wrapper(Initiation init)
+      : initiation_(BOOST_ASIO_MOVE_CAST(Initiation)(init))
+    {
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          experimental::detail::as_tuple_handler<
+            typename decay<Handler>::type>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    Initiation initiation_;
+  };
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken,
+      typename experimental::detail::as_tuple_signature<Signatures>::type...,
+      (base_async_result::initiate(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<CompletionToken>(),
+        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)
+  {
+    return base_async_result::initiate(
+        init_wrapper<typename decay<Initiation>::type>(
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.token_, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::as_tuple_handler<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::as_tuple_handler<Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_AS_TUPLE_HPP

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

@@ -0,0 +1,106 @@
+//
+// experimental/impl/deferred.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2021 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)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_DEFERRED_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_DEFERRED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename R, typename... Args>
+class async_result<
+    experimental::detail::deferred_signature_probe, R(Args...)>
+{
+public:
+  typedef experimental::detail::deferred_signature_probe_result<void(Args...)>
+    return_type;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation),
+      experimental::detail::deferred_signature_probe,
+      BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  {
+    return return_type{};
+  }
+};
+
+template <typename Signature>
+class async_result<experimental::deferred_t, Signature>
+{
+public:
+  template <typename Initiation, typename... InitArgs>
+  static experimental::deferred_async_operation<
+      Signature, Initiation, InitArgs...>
+  initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      experimental::deferred_t, BOOST_ASIO_MOVE_ARG(InitArgs)... args)
+  {
+    return experimental::deferred_async_operation<
+        Signature, Initiation, InitArgs...>(
+          experimental::deferred_init_tag{},
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
+          BOOST_ASIO_MOVE_CAST(InitArgs)(args)...);
+    }
+};
+
+template <typename Function, typename R, typename... Args>
+class async_result<
+    experimental::deferred_function<Function>, R(Args...)>
+{
+public:
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      experimental::deferred_function<Function> token,
+      BOOST_ASIO_MOVE_ARG(InitArgs)... init_args)
+  {
+    return experimental::deferred_sequence<
+        experimental::deferred_async_operation<
+          R(Args...), Initiation, InitArgs...>,
+        Function>(experimental::deferred_init_tag{},
+          experimental::deferred_async_operation<
+            R(Args...), Initiation, InitArgs...>(
+              experimental::deferred_init_tag{},
+              BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
+              BOOST_ASIO_MOVE_CAST(InitArgs)(init_args)...),
+          BOOST_ASIO_MOVE_CAST(Function)(token.function_));
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename Tail, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::deferred_sequence_handler<Handler, Tail>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::deferred_sequence_handler<Handler, Tail>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_DEFERRED_HPP