passenger 6.0.11 → 6.0.12

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

@@ -15,8 +15,7 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.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>
@@ -78,7 +77,7 @@ namespace detail
         const std::size_t bytes_written)
     {
       storage_.consume(bytes_written);
-      handler_(ec, bytes_written);
+      BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_written);
     }
 
   //private:
@@ -183,30 +182,18 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename WriteHandler, typename Allocator>
-struct associated_allocator<
-    detail::buffered_flush_handler<WriteHandler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
+    detail::buffered_flush_handler<WriteHandler>,
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename WriteHandler, typename Executor>
-struct associated_executor<
-    detail::buffered_flush_handler<WriteHandler>, Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
-{
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
+      const detail::buffered_flush_handler<WriteHandler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -294,7 +281,7 @@ namespace detail
       if (ec)
       {
         const std::size_t length = 0;
-        handler_(ec, length);
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, length);
       }
       else
       {
@@ -307,7 +294,7 @@ namespace detail
         storage_.resize(orig_size + length);
         const std::size_t bytes_copied = boost::asio::buffer_copy(
             storage_.data() + orig_size, buffers_, length);
-        handler_(ec, bytes_copied);
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_copied);
       }
     }
 
@@ -435,38 +422,20 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename ConstBufferSequence,
-    typename WriteHandler, typename Allocator>
-struct associated_allocator<
+template <template <typename, typename> class Associator,
+    typename ConstBufferSequence, typename WriteHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(
-      const detail::buffered_write_some_handler<
-        ConstBufferSequence, WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename ConstBufferSequence,
-    typename WriteHandler, typename Executor>
-struct associated_executor<
-    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
-{
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 

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

@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/dispatch.hpp>
 #include <boost/asio/execution/outstanding_work.hpp>
@@ -77,16 +78,18 @@ make_co_spawn_work_guard(const Executor& ex)
 }
 
 template <typename T, typename Executor, typename F, typename Handler>
-awaitable<void, Executor> co_spawn_entry_point(
+awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
     awaitable<T, Executor>*, Executor ex, F f, Handler handler)
 {
   auto spawn_work = make_co_spawn_work_guard(ex);
   auto handler_work = make_co_spawn_work_guard(
       boost::asio::get_associated_executor(handler, ex));
 
-  (void) co_await (post)(spawn_work.get_executor(),
-      use_awaitable_t<Executor>{});
+  (void) co_await (dispatch)(
+      use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
 
+  (co_await awaitable_thread_has_context_switched{}) = false;
+  std::exception_ptr e = nullptr;
   bool done = false;
   try
   {
@@ -94,36 +97,63 @@ awaitable<void, Executor> co_spawn_entry_point(
 
     done = true;
 
-    (dispatch)(handler_work.get_executor(),
-        [handler = std::move(handler), t = std::move(t)]() mutable
-        {
-          handler(std::exception_ptr(), std::move(t));
-        });
+    if (co_await awaitable_thread_has_context_switched{})
+    {
+      (dispatch)(handler_work.get_executor(),
+          [handler = std::move(handler), t = std::move(t)]() mutable
+          {
+            std::move(handler)(std::exception_ptr(), std::move(t));
+          });
+    }
+    else
+    {
+      (post)(handler_work.get_executor(),
+          [handler = std::move(handler), t = std::move(t)]() mutable
+          {
+            std::move(handler)(std::exception_ptr(), std::move(t));
+          });
+    }
+
+    co_return;
   }
   catch (...)
   {
     if (done)
       throw;
 
+    e = std::current_exception();
+  }
+
+  if (co_await awaitable_thread_has_context_switched{})
+  {
     (dispatch)(handler_work.get_executor(),
-        [handler = std::move(handler), e = std::current_exception()]() mutable
+        [handler = std::move(handler), e]() mutable
+        {
+          std::move(handler)(e, T());
+        });
+  }
+  else
+  {
+    (post)(handler_work.get_executor(),
+        [handler = std::move(handler), e]() mutable
         {
-          handler(e, T());
+          std::move(handler)(e, T());
         });
   }
 }
 
 template <typename Executor, typename F, typename Handler>
-awaitable<void, Executor> co_spawn_entry_point(
+awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
     awaitable<void, Executor>*, Executor ex, F f, Handler handler)
 {
   auto spawn_work = make_co_spawn_work_guard(ex);
   auto handler_work = make_co_spawn_work_guard(
       boost::asio::get_associated_executor(handler, ex));
 
-  (void) co_await (post)(spawn_work.get_executor(),
+  (void) co_await (dispatch)(
       use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
 
+  (co_await awaitable_thread_has_context_switched{}) = false;
   std::exception_ptr e = nullptr;
   try
   {
@@ -134,11 +164,22 @@ awaitable<void, Executor> co_spawn_entry_point(
     e = std::current_exception();
   }
 
-  (dispatch)(handler_work.get_executor(),
-      [handler = std::move(handler), e]() mutable
-      {
-        handler(e);
-      });
+  if (co_await awaitable_thread_has_context_switched{})
+  {
+    (dispatch)(handler_work.get_executor(),
+        [handler = std::move(handler), e]() mutable
+        {
+          std::move(handler)(e);
+        });
+  }
+  else
+  {
+    (post)(handler_work.get_executor(),
+        [handler = std::move(handler), e]() mutable
+        {
+          std::move(handler)(e);
+        });
+  }
 }
 
 template <typename T, typename Executor>
@@ -181,9 +222,16 @@ public:
   {
     typedef typename result_of<F()>::type awaitable_type;
 
+    cancellation_state proxy_cancel_state(
+        boost::asio::get_associated_cancellation_slot(handler),
+        enable_total_cancellation());
+
+    cancellation_state cancel_state(proxy_cancel_state.slot());
+
     auto a = (co_spawn_entry_point)(static_cast<awaitable_type*>(nullptr),
         ex_, std::forward<F>(f), std::forward<Handler>(handler));
-    awaitable_handler<executor_type, void>(std::move(a), ex_).launch();
+    awaitable_handler<executor_type, void>(std::move(a), ex_,
+        proxy_cancel_state.slot(), cancel_state).launch();
   }
 
 private:

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

@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/associated_executor.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.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>
@@ -294,13 +295,16 @@ namespace detail
   template <typename Impl, typename Work, typename Handler, typename Signature>
   class composed_op
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+    : public base_from_cancellation_state<Handler>
   {
   public:
     template <typename I, typename W, typename H>
     composed_op(BOOST_ASIO_MOVE_ARG(I) impl,
         BOOST_ASIO_MOVE_ARG(W) work,
         BOOST_ASIO_MOVE_ARG(H) handler)
-      : impl_(BOOST_ASIO_MOVE_CAST(I)(impl)),
+      : base_from_cancellation_state<Handler>(
+          handler, enable_terminal_cancellation()),
+        impl_(BOOST_ASIO_MOVE_CAST(I)(impl)),
         work_(BOOST_ASIO_MOVE_CAST(W)(work)),
         handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
         invocations_(0)
@@ -309,7 +313,10 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     composed_op(composed_op&& other)
-      : impl_(BOOST_ASIO_MOVE_CAST(Impl)(other.impl_)),
+      : base_from_cancellation_state<Handler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            Handler>)(other)),
+        impl_(BOOST_ASIO_MOVE_CAST(Impl)(other.impl_)),
         work_(BOOST_ASIO_MOVE_CAST(Work)(other.work_)),
         handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
         invocations_(other.invocations_)
@@ -343,13 +350,15 @@ namespace detail
     {
       if (invocations_ < ~0u)
         ++invocations_;
+      this->get_cancellation_state().slot().clear();
       impl_(*this, BOOST_ASIO_MOVE_CAST(T)(t)...);
     }
 
     void complete(Args... args)
     {
       this->work_.reset();
-      this->handler_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
     }
 
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
@@ -358,13 +367,14 @@ namespace detail
     {
       if (invocations_ < ~0u)
         ++invocations_;
+      this->get_cancellation_state().slot().clear();
       impl_(*this);
     }
 
     void complete()
     {
       this->work_.reset();
-      this->handler_();
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)();
     }
 
 #define BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF(n) \
@@ -373,6 +383,7 @@ namespace detail
     { \
       if (invocations_ < ~0u) \
         ++invocations_; \
+      this->get_cancellation_state().slot().clear(); \
       impl_(*this, BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
     } \
     \
@@ -380,7 +391,8 @@ namespace detail
     void complete(BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
     { \
       this->work_.reset(); \
-      this->handler_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)( \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
     } \
     /**/
     BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF)
@@ -388,6 +400,27 @@ namespace detail
 
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
+    void reset_cancellation_state()
+    {
+      base_from_cancellation_state<Handler>::reset_cancellation_state(handler_);
+    }
+
+    template <typename Filter>
+    void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+    {
+      base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+          BOOST_ASIO_MOVE_CAST(Filter)(filter));
+    }
+
+    template <typename InFilter, typename OutFilter>
+    void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+        BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+    {
+      base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+          BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+          BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+    }
+
   //private:
     Impl impl_;
     Work work_;
@@ -521,6 +554,23 @@ namespace detail
 } // namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
+
+template <template <typename, typename> class Associator,
+    typename Impl, typename Work, typename Handler,
+    typename Signature, typename DefaultCandidate>
+struct associator<Associator,
+    detail::composed_op<Impl, Work, Handler, Signature>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::composed_op<Impl, Work, Handler, Signature>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename CompletionToken, typename Signature,

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

@@ -16,8 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
@@ -295,14 +295,18 @@ namespace detail
 
   template <typename Protocol, typename Executor, typename EndpointSequence,
       typename ConnectCondition, typename RangeConnectHandler>
-  class range_connect_op : base_from_connect_condition<ConnectCondition>
+  class range_connect_op
+    : public base_from_cancellation_state<RangeConnectHandler>,
+      base_from_connect_condition<ConnectCondition>
   {
   public:
     range_connect_op(basic_socket<Protocol, Executor>& sock,
         const EndpointSequence& endpoints,
         const ConnectCondition& connect_condition,
         RangeConnectHandler& handler)
-      : base_from_connect_condition<ConnectCondition>(connect_condition),
+      : base_from_cancellation_state<RangeConnectHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_connect_condition<ConnectCondition>(connect_condition),
         socket_(sock),
         endpoints_(endpoints),
         index_(0),
@@ -313,7 +317,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     range_connect_op(const range_connect_op& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<RangeConnectHandler>(other),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         endpoints_(other.endpoints_),
         index_(other.index_),
@@ -323,7 +328,10 @@ namespace detail
     }
 
     range_connect_op(range_connect_op&& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<RangeConnectHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            RangeConnectHandler>)(other)),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         endpoints_(other.endpoints_),
         index_(other.index_),
@@ -389,11 +397,18 @@ namespace detail
           if (!ec)
             break;
 
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
           ++iter;
           ++index_;
         }
 
-        handler_(static_cast<const boost::system::error_code&>(ec),
+        BOOST_ASIO_MOVE_OR_LVALUE(RangeConnectHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
             static_cast<const typename Protocol::endpoint&>(
               ec || iter == end ? typename Protocol::endpoint() : *iter));
       }
@@ -516,14 +531,18 @@ namespace detail
 
   template <typename Protocol, typename Executor, typename Iterator,
       typename ConnectCondition, typename IteratorConnectHandler>
-  class iterator_connect_op : base_from_connect_condition<ConnectCondition>
+  class iterator_connect_op
+    : public base_from_cancellation_state<IteratorConnectHandler>,
+      base_from_connect_condition<ConnectCondition>
   {
   public:
     iterator_connect_op(basic_socket<Protocol, Executor>& sock,
         const Iterator& begin, const Iterator& end,
         const ConnectCondition& connect_condition,
         IteratorConnectHandler& handler)
-      : base_from_connect_condition<ConnectCondition>(connect_condition),
+      : base_from_cancellation_state<IteratorConnectHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_connect_condition<ConnectCondition>(connect_condition),
         socket_(sock),
         iter_(begin),
         end_(end),
@@ -534,7 +553,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     iterator_connect_op(const iterator_connect_op& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<IteratorConnectHandler>(other),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
@@ -544,7 +564,10 @@ namespace detail
     }
 
     iterator_connect_op(iterator_connect_op&& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<IteratorConnectHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            IteratorConnectHandler>)(other)),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
@@ -596,10 +619,17 @@ namespace detail
           if (!ec)
             break;
 
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
           ++iter_;
         }
 
-        handler_(static_cast<const boost::system::error_code&>(ec),
+        BOOST_ASIO_MOVE_OR_LVALUE(IteratorConnectHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
             static_cast<const Iterator&>(iter_));
       }
     }
@@ -724,86 +754,44 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename Protocol, typename Executor, typename EndpointSequence,
-    typename ConnectCondition, typename RangeConnectHandler, typename Allocator>
-struct associated_allocator<
-    detail::range_connect_op<Protocol, Executor, EndpointSequence,
-      ConnectCondition, RangeConnectHandler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Protocol, typename Executor, typename EndpointSequence,
+    typename ConnectCondition, typename RangeConnectHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::range_connect_op<Protocol, Executor,
+      EndpointSequence, ConnectCondition, RangeConnectHandler>,
+    DefaultCandidate>
+  : Associator<RangeConnectHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<
-      RangeConnectHandler, Allocator>::type type;
-
-  static type get(
-      const detail::range_connect_op<Protocol, Executor, EndpointSequence,
-        ConnectCondition, RangeConnectHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<RangeConnectHandler, DefaultCandidate>::type get(
+      const detail::range_connect_op<Protocol, Executor,
+        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<RangeConnectHandler,
-        Allocator>::get(h.handler_, a);
+    return Associator<RangeConnectHandler, DefaultCandidate>::get(
+        h.handler_, c);
   }
 };
 
-template <typename Protocol, typename Executor, typename EndpointSequence,
-    typename ConnectCondition, typename RangeConnectHandler, typename Executor1>
-struct associated_executor<
-    detail::range_connect_op<Protocol, Executor, EndpointSequence,
-      ConnectCondition, RangeConnectHandler>, Executor1>
-  : detail::associated_executor_forwarding_base<RangeConnectHandler, Executor1>
-{
-  typedef typename associated_executor<
-      RangeConnectHandler, Executor1>::type type;
-
-  static type get(
-      const detail::range_connect_op<Protocol, Executor, EndpointSequence,
-      ConnectCondition, RangeConnectHandler>& h,
-      const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<RangeConnectHandler,
-        Executor1>::get(h.handler_, ex);
-  }
-};
-
-template <typename Protocol, typename Executor, typename Iterator,
-    typename ConnectCondition, typename IteratorConnectHandler,
-    typename Allocator>
-struct associated_allocator<
-    detail::iterator_connect_op<Protocol, Executor,
-      Iterator, ConnectCondition, IteratorConnectHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<
-      IteratorConnectHandler, Allocator>::type type;
-
-  static type get(
-      const detail::iterator_connect_op<Protocol, Executor,
-        Iterator, ConnectCondition, IteratorConnectHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<IteratorConnectHandler,
-        Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename Protocol, typename Executor, typename Iterator,
+template <template <typename, typename> class Associator,
+    typename Protocol, typename Executor, typename Iterator,
     typename ConnectCondition, typename IteratorConnectHandler,
-    typename Executor1>
-struct associated_executor<
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::iterator_connect_op<Protocol, Executor,
       Iterator, ConnectCondition, IteratorConnectHandler>,
-    Executor1>
-  : detail::associated_executor_forwarding_base<
-      IteratorConnectHandler, Executor1>
+    DefaultCandidate>
+  : Associator<IteratorConnectHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<
-      IteratorConnectHandler, Executor1>::type type;
-
-  static type get(
+  static typename Associator<IteratorConnectHandler, DefaultCandidate>::type
+  get(
       const detail::iterator_connect_op<Protocol, Executor,
         Iterator, ConnectCondition, IteratorConnectHandler>& h,
-      const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<IteratorConnectHandler,
-        Executor1>::get(h.handler_, ex);
+    return Associator<IteratorConnectHandler, DefaultCandidate>::get(
+        h.handler_, c);
   }
 };