passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/src.cpp

@@ -2,14 +2,14 @@
 // impl/src.cpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2020 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)
 //
 
 #if defined(_MSC_VER) \
-  || defined(__BORLANDC__) \
+  || (defined(__BORLANDC__) && !defined(__clang__)) \
   || defined(__DMC__)
 # pragma message ( \
     "This file is deprecated. " \

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

@@ -2,7 +2,7 @@
 // impl/src.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2020 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)
@@ -24,6 +24,7 @@
 #include <boost/asio/impl/executor.ipp>
 #include <boost/asio/impl/handler_alloc_hook.ipp>
 #include <boost/asio/impl/io_context.ipp>
+#include <boost/asio/impl/multiple_exceptions.ipp>
 #include <boost/asio/impl/serial_port_base.ipp>
 #include <boost/asio/impl/system_context.ipp>
 #include <boost/asio/impl/thread_pool.ipp>
@@ -68,6 +69,8 @@
 #include <boost/asio/detail/impl/winrt_ssocket_service_base.ipp>
 #include <boost/asio/detail/impl/winrt_timer_scheduler.ipp>
 #include <boost/asio/detail/impl/winsock_init.ipp>
+#include <boost/asio/execution/impl/bad_executor.ipp>
+#include <boost/asio/execution/impl/receiver_invocation_error.ipp>
 #include <boost/asio/generic/detail/impl/endpoint.ipp>
 #include <boost/asio/ip/impl/address.ipp>
 #include <boost/asio/ip/impl/address_v4.ipp>

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

@@ -2,7 +2,7 @@
 // impl/system_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2020 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)

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/system_context.ipp

@@ -2,7 +2,7 @@
 // impl/system_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2020 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)
@@ -29,19 +29,31 @@ struct system_context::thread_function
 
   void operator()()
   {
-    boost::system::error_code ec;
-    scheduler_->run(ec);
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
+      boost::system::error_code ec;
+      scheduler_->run(ec);
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      std::terminate();
+    }
+#endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
   }
 };
 
 system_context::system_context()
-  : scheduler_(use_service<detail::scheduler>(*this))
+  : scheduler_(add_scheduler(new detail::scheduler(*this, 0, false)))
 {
   scheduler_.work_started();
 
   thread_function f = { &scheduler_ };
-  std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
-  threads_.create_threads(f, num_threads ? num_threads : 2);
+  num_threads_ = detail::thread::hardware_concurrency() * 2;
+  num_threads_ = num_threads_ ? num_threads_ : 2;
+  threads_.create_threads(f, num_threads_);
 }
 
 system_context::~system_context()
@@ -67,6 +79,13 @@ void system_context::join()
   threads_.join();
 }
 
+detail::scheduler& system_context::add_scheduler(detail::scheduler* s)
+{
+  detail::scoped_ptr<detail::scheduler> scoped_impl(s);
+  boost::asio::add_service<detail::scheduler>(*this, scoped_impl.get());
+  return *scoped_impl.release();
+}
+
 } // namespace asio
 } // namespace boost
 

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

@@ -2,7 +2,7 @@
 // impl/system_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2020 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)
@@ -26,29 +26,128 @@
 namespace boost {
 namespace asio {
 
-inline system_context& system_executor::context() const BOOST_ASIO_NOEXCEPT
+template <typename Blocking, typename Relationship, typename Allocator>
+inline system_context&
+basic_system_executor<Blocking, Relationship, Allocator>::query(
+    execution::context_t) BOOST_ASIO_NOEXCEPT
 {
   return detail::global<system_context>();
 }
 
-template <typename Function, typename Allocator>
-void system_executor::dispatch(
-    BOOST_ASIO_MOVE_ARG(Function) f, const Allocator&) const
+template <typename Blocking, typename Relationship, typename Allocator>
+inline std::size_t
+basic_system_executor<Blocking, Relationship, Allocator>::query(
+    execution::occupancy_t) const BOOST_ASIO_NOEXCEPT
+{
+  return detail::global<system_context>().num_threads_;
+}
+
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function>
+inline void
+basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
+    BOOST_ASIO_MOVE_ARG(Function) f, execution::blocking_t::possibly_t) const
+{
+  // Obtain a non-const instance of the function.
+  detail::non_const_lvalue<Function> f2(f);
+
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  try
+  {
+#endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    detail::fenced_block b(detail::fenced_block::full);
+    boost_asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  }
+  catch (...)
+  {
+    std::terminate();
+  }
+#endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
+}
+
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function>
+inline void
+basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
+    BOOST_ASIO_MOVE_ARG(Function) f, execution::blocking_t::always_t) const
+{
+  // Obtain a non-const instance of the function.
+  detail::non_const_lvalue<Function> f2(f);
+
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  try
+  {
+#endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    detail::fenced_block b(detail::fenced_block::full);
+    boost_asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  }
+  catch (...)
+  {
+    std::terminate();
+  }
+#endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
+}
+
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function>
+void basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
+    BOOST_ASIO_MOVE_ARG(Function) f, execution::blocking_t::never_t) const
+{
+  system_context& ctx = detail::global<system_context>();
+
+  // Allocate and construct an operation to wrap the function.
+  typedef typename decay<Function>::type function_type;
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(allocator_),
+      op::ptr::allocate(allocator_), 0 };
+  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_);
+
+  if (is_same<Relationship, execution::relationship_t::continuation_t>::value)
+  {
+    BOOST_ASIO_HANDLER_CREATION((ctx, *p.p,
+          "system_executor", &ctx, 0, "execute(blk=never,rel=cont)"));
+  }
+  else
+  {
+    BOOST_ASIO_HANDLER_CREATION((ctx, *p.p,
+          "system_executor", &ctx, 0, "execute(blk=never,rel=fork)"));
+  }
+
+  ctx.scheduler_.post_immediate_completion(p.p,
+      is_same<Relationship, execution::relationship_t::continuation_t>::value);
+  p.v = p.p = 0;
+}
+
+#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+template <typename Blocking, typename Relationship, typename Allocator>
+inline system_context& basic_system_executor<
+    Blocking, Relationship, Allocator>::context() const BOOST_ASIO_NOEXCEPT
+{
+  return detail::global<system_context>();
+}
+
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function, typename OtherAllocator>
+void basic_system_executor<Blocking, Relationship, Allocator>::dispatch(
+    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator&) const
 {
   typename decay<Function>::type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
   boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
 }
 
-template <typename Function, typename Allocator>
-void system_executor::post(
-    BOOST_ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function, typename OtherAllocator>
+void basic_system_executor<Blocking, Relationship, Allocator>::post(
+    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   system_context& ctx = detail::global<system_context>();
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
@@ -59,16 +158,17 @@ void system_executor::post(
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void system_executor::defer(
-    BOOST_ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function, typename OtherAllocator>
+void basic_system_executor<Blocking, Relationship, Allocator>::defer(
+    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   system_context& ctx = detail::global<system_context>();
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
@@ -78,6 +178,7 @@ void system_executor::defer(
   ctx.scheduler_.post_immediate_completion(p.p, true);
   p.v = p.p = 0;
 }
+#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 } // namespace asio
 } // namespace boost

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

@@ -2,7 +2,7 @@
 // impl/thread_pool.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2020 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)
@@ -15,8 +15,11 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/blocking_executor_op.hpp>
+#include <boost/asio/detail/bulk_executor_op.hpp>
 #include <boost/asio/detail/executor_op.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
 #include <boost/asio/detail/recycling_allocator.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution_context.hpp>
@@ -32,32 +35,255 @@ thread_pool::get_executor() BOOST_ASIO_NOEXCEPT
   return executor_type(*this);
 }
 
-inline thread_pool&
-thread_pool::executor_type::context() const BOOST_ASIO_NOEXCEPT
+inline thread_pool::executor_type
+thread_pool::executor() BOOST_ASIO_NOEXCEPT
+{
+  return executor_type(*this);
+}
+
+inline thread_pool::scheduler_type
+thread_pool::scheduler() BOOST_ASIO_NOEXCEPT
+{
+  return scheduler_type(*this);
+}
+
+template <typename Allocator, unsigned int Bits>
+thread_pool::basic_executor_type<Allocator, Bits>&
+thread_pool::basic_executor_type<Allocator, Bits>::operator=(
+    const basic_executor_type& other) BOOST_ASIO_NOEXCEPT
+{
+  if (this != &other)
+  {
+    thread_pool* old_thread_pool = pool_;
+    pool_ = other.pool_;
+    allocator_ = other.allocator_;
+    bits_ = other.bits_;
+    if (Bits & outstanding_work_tracked)
+    {
+      if (pool_)
+        pool_->scheduler_.work_started();
+      if (old_thread_pool)
+        old_thread_pool->scheduler_.work_finished();
+    }
+  }
+  return *this;
+}
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+template <typename Allocator, unsigned int Bits>
+thread_pool::basic_executor_type<Allocator, Bits>&
+thread_pool::basic_executor_type<Allocator, Bits>::operator=(
+    basic_executor_type&& other) BOOST_ASIO_NOEXCEPT
+{
+  if (this != &other)
+  {
+    pool_ = other.pool_;
+    allocator_ = std::move(other.allocator_);
+    bits_ = other.bits_;
+    if (Bits & outstanding_work_tracked)
+      other.pool_ = 0;
+  }
+  return *this;
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+template <typename Allocator, unsigned int Bits>
+inline bool thread_pool::basic_executor_type<Allocator,
+    Bits>::running_in_this_thread() const BOOST_ASIO_NOEXCEPT
+{
+  return pool_->scheduler_.can_dispatch();
+}
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator,
+    Bits>::do_execute(BOOST_ASIO_MOVE_ARG(Function) f, false_type) const
+{
+  typedef typename decay<Function>::type function_type;
+
+  // Invoke immediately if the blocking.possibly property is enabled and we are
+  // already inside the thread pool.
+  if ((bits_ & blocking_never) == 0 && pool_->scheduler_.can_dispatch())
+  {
+    // Make a local, non-const copy of the function.
+    function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
+
+#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+       //   && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+      detail::fenced_block b(detail::fenced_block::full);
+      boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
+      return;
+#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      pool_->scheduler_.capture_current_exception();
+      return;
+    }
+#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
+       //   && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  }
+
+  // Allocate and construct an operation to wrap the function.
+  typedef detail::executor_op<function_type, Allocator> op;
+  typename op::ptr p = { detail::addressof(allocator_),
+      op::ptr::allocate(allocator_), 0 };
+  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_);
+
+  if ((bits_ & relationship_continuation) != 0)
+  {
+    BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+          "thread_pool", pool_, 0, "execute(blk=never,rel=cont)"));
+  }
+  else
+  {
+    BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+          "thread_pool", pool_, 0, "execute(blk=never,rel=fork)"));
+  }
+
+  pool_->scheduler_.post_immediate_completion(p.p,
+      (bits_ & relationship_continuation) != 0);
+  p.v = p.p = 0;
+}
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator,
+    Bits>::do_execute(BOOST_ASIO_MOVE_ARG(Function) f, true_type) const
 {
-  return pool_;
+  // Obtain a non-const instance of the function.
+  detail::non_const_lvalue<Function> f2(f);
+
+  // Invoke immediately if we are already inside the thread pool.
+  if (pool_->scheduler_.can_dispatch())
+  {
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+      detail::fenced_block b(detail::fenced_block::full);
+      boost_asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+      return;
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      std::terminate();
+    }
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  }
+
+  // Construct an operation to wrap the function.
+  typedef typename decay<Function>::type function_type;
+  detail::blocking_executor_op<function_type> op(f2.value);
+
+  BOOST_ASIO_HANDLER_CREATION((*pool_, op,
+        "thread_pool", pool_, 0, "execute(blk=always)"));
+
+  pool_->scheduler_.post_immediate_completion(&op, false);
+  op.wait();
 }
 
-inline void
-thread_pool::executor_type::on_work_started() const BOOST_ASIO_NOEXCEPT
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
+    BOOST_ASIO_MOVE_ARG(Function) f, std::size_t n, false_type) const
 {
-  pool_.scheduler_.work_started();
+  typedef typename decay<Function>::type function_type;
+  typedef detail::bulk_executor_op<function_type, Allocator> op;
+
+  // Allocate and construct operations to wrap the function.
+  detail::op_queue<detail::scheduler_operation> ops;
+  for (std::size_t i = 0; i < n; ++i)
+  {
+    typename op::ptr p = { detail::addressof(allocator_),
+        op::ptr::allocate(allocator_), 0 };
+    p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_, i);
+    ops.push(p.p);
+
+    if ((bits_ & relationship_continuation) != 0)
+    {
+      BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+            "thread_pool", pool_, 0, "bulk_execute(blk=never,rel=cont)"));
+    }
+    else
+    {
+      BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+            "thread_pool", pool_, 0, "bulk)execute(blk=never,rel=fork)"));
+    }
+
+    p.v = p.p = 0;
+  }
+
+  pool_->scheduler_.post_immediate_completions(n,
+      ops, (bits_ & relationship_continuation) != 0);
 }
 
-inline void thread_pool::executor_type::on_work_finished()
-const BOOST_ASIO_NOEXCEPT
+template <typename Function>
+struct thread_pool_always_blocking_function_adapter
 {
-  pool_.scheduler_.work_finished();
+  typename decay<Function>::type* f;
+  std::size_t n;
+
+  void operator()()
+  {
+    for (std::size_t i = 0; i < n; ++i)
+    {
+      (*f)(i);
+    }
+  }
+};
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function>
+void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
+    BOOST_ASIO_MOVE_ARG(Function) f, std::size_t n, true_type) const
+{
+  // Obtain a non-const instance of the function.
+  detail::non_const_lvalue<Function> f2(f);
+
+  thread_pool_always_blocking_function_adapter<Function>
+    adapter = { detail::addressof(f2.value), n };
+
+  this->do_execute(adapter, true_type());
+}
+
+#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+template <typename Allocator, unsigned int Bits>
+inline thread_pool& thread_pool::basic_executor_type<
+    Allocator, Bits>::context() const BOOST_ASIO_NOEXCEPT
+{
+  return *pool_;
+}
+
+template <typename Allocator, unsigned int Bits>
+inline void thread_pool::basic_executor_type<Allocator,
+    Bits>::on_work_started() const BOOST_ASIO_NOEXCEPT
+{
+  pool_->scheduler_.work_started();
 }
 
-template <typename Function, typename Allocator>
-void thread_pool::executor_type::dispatch(
-    BOOST_ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Allocator, unsigned int Bits>
+inline void thread_pool::basic_executor_type<Allocator,
+    Bits>::on_work_finished() const BOOST_ASIO_NOEXCEPT
+{
+  pool_->scheduler_.work_finished();
+}
+
+template <typename Allocator, unsigned int Bits>
+template <typename Function, typename OtherAllocator>
+void thread_pool::basic_executor_type<Allocator, Bits>::dispatch(
+    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   // Invoke immediately if we are already inside the thread pool.
-  if (pool_.scheduler_.can_dispatch())
+  if (pool_->scheduler_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
     function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
@@ -68,58 +294,55 @@ void thread_pool::executor_type::dispatch(
   }
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
-  BOOST_ASIO_HANDLER_CREATION((pool_, *p.p,
-        "thread_pool", &this->context(), 0, "dispatch"));
+  BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+        "thread_pool", pool_, 0, "dispatch"));
 
-  pool_.scheduler_.post_immediate_completion(p.p, false);
+  pool_->scheduler_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void thread_pool::executor_type::post(
-    BOOST_ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Allocator, unsigned int Bits>
+template <typename Function, typename OtherAllocator>
+void thread_pool::basic_executor_type<Allocator, Bits>::post(
+    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
-  BOOST_ASIO_HANDLER_CREATION((pool_, *p.p,
-        "thread_pool", &this->context(), 0, "post"));
+  BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+        "thread_pool", pool_, 0, "post"));
 
-  pool_.scheduler_.post_immediate_completion(p.p, false);
+  pool_->scheduler_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void thread_pool::executor_type::defer(
-    BOOST_ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+template <typename Allocator, unsigned int Bits>
+template <typename Function, typename OtherAllocator>
+void thread_pool::basic_executor_type<Allocator, Bits>::defer(
+    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
 {
   typedef typename decay<Function>::type function_type;
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
-  BOOST_ASIO_HANDLER_CREATION((pool_, *p.p,
-        "thread_pool", &this->context(), 0, "defer"));
+  BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
+        "thread_pool", pool_, 0, "defer"));
 
-  pool_.scheduler_.post_immediate_completion(p.p, true);
+  pool_->scheduler_.post_immediate_completion(p.p, true);
   p.v = p.p = 0;
 }
-
-inline bool
-thread_pool::executor_type::running_in_this_thread() const BOOST_ASIO_NOEXCEPT
-{
-  return pool_.scheduler_.can_dispatch();
-}
+#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 } // namespace asio
 } // namespace boost