passenger 6.0.16 → 6.0.17

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

@@ -0,0 +1,90 @@
+//
+// consign.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 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_CONSIGN_HPP
+#define BOOST_ASIO_CONSIGN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if (defined(BOOST_ASIO_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <tuple>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Completion token type used to specify that the completion handler should
+/// carry additional values along with it.
+/**
+ * This completion token adapter is typically used to keep at least one copy of
+ * an object, such as a smart pointer, alive until the completion handler is
+ * called.
+ */
+template <typename CompletionToken, typename... Values>
+class consign_t
+{
+public:
+  /// Constructor.
+  template <typename T, typename... V>
+  BOOST_ASIO_CONSTEXPR explicit consign_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token,
+      BOOST_ASIO_MOVE_ARG(V)... values)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token)),
+      values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+private:
+#endif // defined(GENERATING_DOCUMENTATION)
+  CompletionToken token_;
+  std::tuple<Values...> values_;
+};
+
+/// Completion token adapter used to specify that the completion handler should
+/// carry additional values along with it.
+/**
+ * This completion token adapter is typically used to keep at least one copy of
+ * an object, such as a smart pointer, alive until the completion handler is
+ * called.
+ */
+template <typename CompletionToken, typename... Values>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR consign_t<
+  typename decay<CompletionToken>::type, typename decay<Values>::type...>
+consign(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
+    BOOST_ASIO_MOVE_ARG(Values)... values)
+{
+  return consign_t<
+    typename decay<CompletionToken>::type, typename decay<Values>::type...>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token),
+      BOOST_ASIO_MOVE_CAST(Values)(values)...);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/consign.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_CONSIGN_HPP

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

@@ -19,8 +19,10 @@
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution_context.hpp>
+#include <boost/asio/execution/blocking.hpp>
 #include <boost/asio/execution/executor.hpp>
 #include <boost/asio/is_executor.hpp>
+#include <boost/asio/require.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -68,12 +70,11 @@ template <typename> class initiate_defer_with_executor;
  * @code auto alloc = get_associated_allocator(handler); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code execution::execute(
- *     prefer(
- *       require(ex, execution::blocking.never),
- *       execution::relationship.continuation,
- *       execution::allocator(alloc)),
- *     std::forward<CompletionHandler>(completion_handler)); @endcode
+ * @code prefer(
+ *     require(ex, execution::blocking.never),
+ *     execution::relationship.continuation,
+ *     execution::allocator(alloc)
+ *   ).execute(std::forward<CompletionHandler>(completion_handler)); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
  * @code ex.defer(
@@ -137,11 +138,8 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
  * handler_ that is a decay-copy of @c completion_handler, and a function call
  * operator that performs:
  * @code auto a = get_associated_allocator(handler_);
- * execution::execute(
- *     prefer(executor_,
- *       execution::blocking.possibly,
- *       execution::allocator(a)),
- *     std::move(handler_)); @endcode
+ * prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
+ * @endcode
  *
  * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
  * function object @c f with a member @c work_ that is initialised with
@@ -152,12 +150,11 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
  * work_.reset(); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code execution::execute(
- *     prefer(
- *       require(ex, execution::blocking.never),
- *       execution::relationship.continuation,
- *       execution::allocator(alloc)),
- *     std::move(f)); @endcode
+ * @code prefer(
+ *     require(ex, execution::blocking.never),
+ *     execution::relationship.continuation,
+ *     execution::allocator(alloc)
+ *   ).execute(std::move(f)); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
  * @code ex.defer(std::move(f), alloc); @endcode
@@ -173,7 +170,9 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
     BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<
-      execution::is_executor<Executor>::value || is_executor<Executor>::value
+      (execution::is_executor<Executor>::value
+          && can_require<Executor, execution::blocking_t::never_t>::value)
+        || is_executor<Executor>::value
     >::type = 0)
   BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
     async_initiate<NullaryToken, void()>(

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/bind_handler.hpp

@@ -950,9 +950,18 @@ struct associator<Associator,
     detail::binder0<Handler>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder0<Handler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder0<Handler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder0<Handler>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -964,9 +973,18 @@ struct associator<Associator,
     detail::binder1<Handler, Arg1>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder1<Handler, Arg1>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder1<Handler, Arg1>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder1<Handler, Arg1>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -979,9 +997,18 @@ struct associator<Associator,
     detail::binder2<Handler, Arg1, Arg2>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder2<Handler, Arg1, Arg2>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder2<Handler, Arg1, Arg2>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder2<Handler, Arg1, Arg2>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -994,9 +1021,18 @@ struct associator<Associator,
     detail::binder3<Handler, Arg1, Arg2, Arg3>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder3<Handler, Arg1, Arg2, Arg3>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder3<Handler, Arg1, Arg2, Arg3>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder3<Handler, Arg1, Arg2, Arg3>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -1009,9 +1045,19 @@ struct associator<Associator,
     detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -1024,9 +1070,19 @@ struct associator<Associator,
     detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -1040,9 +1096,18 @@ struct associator<Associator,
     detail::move_binder1<Handler, Arg1>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::move_binder1<Handler, Arg1>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::move_binder1<Handler, Arg1>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::move_binder1<Handler, Arg1>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -1055,9 +1120,18 @@ struct associator<Associator,
     detail::move_binder2<Handler, Arg1, Arg2>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::move_binder2<Handler, Arg1, Arg2>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::move_binder2<Handler, Arg1, Arg2>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/composed_work.hpp

@@ -0,0 +1,330 @@
+//
+// detail/composed_work.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 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_DETAIL_COMPOSED_WORK_HPP
+#define BOOST_ASIO_DETAIL_COMPOSED_WORK_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/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution/outstanding_work.hpp>
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/system_executor.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Executor, typename = void>
+class composed_work_guard
+{
+public:
+  typedef typename decay<
+      typename prefer_result<Executor,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  composed_work_guard(const Executor& ex)
+    : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  void reset()
+  {
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+private:
+  executor_type executor_;
+};
+
+template <>
+struct composed_work_guard<system_executor>
+{
+public:
+  typedef system_executor executor_type;
+
+  composed_work_guard(const system_executor&)
+  {
+  }
+
+  void reset()
+  {
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return system_executor();
+  }
+};
+
+#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+struct composed_work_guard<Executor,
+    typename enable_if<
+      !execution::is_executor<Executor>::value
+    >::type> : executor_work_guard<Executor>
+{
+  composed_work_guard(const Executor& ex)
+    : executor_work_guard<Executor>(ex)
+  {
+  }
+};
+
+#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename>
+struct composed_io_executors;
+
+template <>
+struct composed_io_executors<void()>
+{
+  composed_io_executors() BOOST_ASIO_NOEXCEPT
+    : head_(system_executor())
+  {
+  }
+
+  typedef system_executor head_type;
+  system_executor head_;
+};
+
+inline composed_io_executors<void()> make_composed_io_executors()
+{
+  return composed_io_executors<void()>();
+}
+
+template <typename Head>
+struct composed_io_executors<void(Head)>
+{
+  explicit composed_io_executors(const Head& ex) BOOST_ASIO_NOEXCEPT
+    : head_(ex)
+  {
+  }
+
+  typedef Head head_type;
+  Head head_;
+};
+
+template <typename Head>
+inline composed_io_executors<void(Head)>
+make_composed_io_executors(const Head& head)
+{
+  return composed_io_executors<void(Head)>(head);
+}
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Head, typename... Tail>
+struct composed_io_executors<void(Head, Tail...)>
+{
+  explicit composed_io_executors(const Head& head,
+      const Tail&... tail) BOOST_ASIO_NOEXCEPT
+    : head_(head),
+      tail_(tail...)
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+    tail_.reset();
+  }
+
+  typedef Head head_type;
+  Head head_;
+  composed_io_executors<void(Tail...)> tail_;
+};
+
+template <typename Head, typename... Tail>
+inline composed_io_executors<void(Head, Tail...)>
+make_composed_io_executors(const Head& head, const Tail&... tail)
+{
+  return composed_io_executors<void(Head, Tail...)>(head, tail...);
+}
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define BOOST_ASIO_PRIVATE_COMPOSED_IO_EXECUTORS_DEF(n) \
+template <typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+struct composed_io_executors<void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
+{ \
+  explicit composed_io_executors(const Head& head, \
+      BOOST_ASIO_VARIADIC_CONSTREF_PARAMS(n)) BOOST_ASIO_NOEXCEPT \
+    : head_(head), \
+      tail_(BOOST_ASIO_VARIADIC_BYVAL_ARGS(n)) \
+  { \
+  } \
+\
+  void reset() \
+  { \
+    head_.reset(); \
+    tail_.reset(); \
+  } \
+\
+  typedef Head head_type; \
+  Head head_; \
+  composed_io_executors<void(BOOST_ASIO_VARIADIC_TARGS(n))> tail_; \
+}; \
+\
+template <typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+inline composed_io_executors<void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
+make_composed_io_executors(const Head& head, \
+    BOOST_ASIO_VARIADIC_CONSTREF_PARAMS(n)) \
+{ \
+  return composed_io_executors< \
+    void(Head, BOOST_ASIO_VARIADIC_TARGS(n))>( \
+      head, BOOST_ASIO_VARIADIC_BYVAL_ARGS(n)); \
+} \
+/**/
+BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_IO_EXECUTORS_DEF)
+#undef BOOST_ASIO_PRIVATE_COMPOSED_IO_EXECUTORS_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename>
+struct composed_work;
+
+template <>
+struct composed_work<void()>
+{
+  typedef composed_io_executors<void()> executors_type;
+
+  composed_work(const executors_type&) BOOST_ASIO_NOEXCEPT
+    : head_(system_executor())
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+  }
+
+  typedef system_executor head_type;
+  composed_work_guard<system_executor> head_;
+};
+
+template <typename Head>
+struct composed_work<void(Head)>
+{
+  typedef composed_io_executors<void(Head)> executors_type;
+
+  explicit composed_work(const executors_type& ex) BOOST_ASIO_NOEXCEPT
+    : head_(ex.head_)
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+  }
+
+  typedef Head head_type;
+  composed_work_guard<Head> head_;
+};
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Head, typename... Tail>
+struct composed_work<void(Head, Tail...)>
+{
+  typedef composed_io_executors<void(Head, Tail...)> executors_type;
+
+  explicit composed_work(const executors_type& ex) BOOST_ASIO_NOEXCEPT
+    : head_(ex.head_),
+      tail_(ex.tail_)
+  {
+  }
+
+  void reset()
+  {
+    head_.reset();
+    tail_.reset();
+  }
+
+  typedef Head head_type;
+  composed_work_guard<Head> head_;
+  composed_work<void(Tail...)> tail_;
+};
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define BOOST_ASIO_PRIVATE_COMPOSED_WORK_DEF(n) \
+template <typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+struct composed_work<void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
+{ \
+  typedef composed_io_executors<void(Head, \
+    BOOST_ASIO_VARIADIC_TARGS(n))> executors_type; \
+\
+  explicit composed_work(const executors_type& ex) BOOST_ASIO_NOEXCEPT \
+    : head_(ex.head_), \
+      tail_(ex.tail_) \
+  { \
+  } \
+\
+  void reset() \
+  { \
+    head_.reset(); \
+    tail_.reset(); \
+  } \
+\
+  typedef Head head_type; \
+  composed_work_guard<Head> head_; \
+  composed_work<void(BOOST_ASIO_VARIADIC_TARGS(n))> tail_; \
+}; \
+/**/
+BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_WORK_DEF)
+#undef BOOST_ASIO_PRIVATE_COMPOSED_WORK_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename IoObject>
+inline typename IoObject::executor_type
+get_composed_io_executor(IoObject& io_object,
+    typename enable_if<
+      !is_executor<IoObject>::value
+    >::type* = 0,
+    typename enable_if<
+      !execution::is_executor<IoObject>::value
+    >::type* = 0)
+{
+  return io_object.get_executor();
+}
+
+template <typename Executor>
+inline const Executor& get_composed_io_executor(const Executor& ex,
+    typename enable_if<
+      is_executor<Executor>::value
+        || execution::is_executor<Executor>::value
+    >::type* = 0)
+{
+  return ex;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_COMPOSED_WORK_HPP