RubyGems - couchbase - Versions diffs - 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19 - Mend

couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

Files changed (1318) hide show

data/ext/third_party/asio/asio/include/asio/impl/executor.hpp DELETED

@@ -1,301 +0,0 @@
-//
-// impl/executor.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// 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)
-//
-#ifndef ASIO_IMPL_EXECUTOR_HPP
-#define ASIO_IMPL_EXECUTOR_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#if !defined(ASIO_NO_TS_EXECUTORS)
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/global.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/executor.hpp"
-#include "asio/system_executor.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-#if !defined(GENERATING_DOCUMENTATION)
-// Default polymorphic executor implementation.
-template <typename Executor, typename Allocator>
-class executor::impl
-  : public executor::impl_base
-{
-public:
-  typedef ASIO_REBIND_ALLOC(Allocator, impl) allocator_type;
-  static impl_base* create(const Executor& e, Allocator a = Allocator())
-  {
-    raw_mem mem(a);
-    impl* p = new (mem.ptr_) impl(e, a);
-    mem.ptr_ = 0;
-    return p;
-  }
-  impl(const Executor& e, const Allocator& a) ASIO_NOEXCEPT
-    : impl_base(false),
-      ref_count_(1),
-      executor_(e),
-      allocator_(a)
-  {
-  }
-  impl_base* clone() const ASIO_NOEXCEPT
-  {
-    detail::ref_count_up(ref_count_);
-    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
-  }
-  void destroy() ASIO_NOEXCEPT
-  {
-    if (detail::ref_count_down(ref_count_))
-    {
-      allocator_type alloc(allocator_);
-      impl* p = this;
-      p->~impl();
-      alloc.deallocate(p, 1);
-    }
-  }
-  void on_work_started() ASIO_NOEXCEPT
-  {
-    executor_.on_work_started();
-  }
-  void on_work_finished() ASIO_NOEXCEPT
-  {
-    executor_.on_work_finished();
-  }
-  execution_context& context() ASIO_NOEXCEPT
-  {
-    return executor_.context();
-  }
-  void dispatch(ASIO_MOVE_ARG(function) f)
-  {
-    executor_.dispatch(ASIO_MOVE_CAST(function)(f), allocator_);
-  }
-  void post(ASIO_MOVE_ARG(function) f)
-  {
-    executor_.post(ASIO_MOVE_CAST(function)(f), allocator_);
-  }
-  void defer(ASIO_MOVE_ARG(function) f)
-  {
-    executor_.defer(ASIO_MOVE_CAST(function)(f), allocator_);
-  }
-  type_id_result_type target_type() const ASIO_NOEXCEPT
-  {
-    return type_id<Executor>();
-  }
-  void* target() ASIO_NOEXCEPT
-  {
-    return &executor_;
-  }
-  const void* target() const ASIO_NOEXCEPT
-  {
-    return &executor_;
-  }
-  bool equals(const impl_base* e) const ASIO_NOEXCEPT
-  {
-    if (this == e)
-      return true;
-    if (target_type() != e->target_type())
-      return false;
-    return executor_ == *static_cast<const Executor*>(e->target());
-  }
-private:
-  mutable detail::atomic_count ref_count_;
-  Executor executor_;
-  Allocator allocator_;
-  struct raw_mem
-  {
-    allocator_type allocator_;
-    impl* ptr_;
-    explicit raw_mem(const Allocator& a)
-      : allocator_(a),
-        ptr_(allocator_.allocate(1))
-    {
-    }
-    ~raw_mem()
-    {
-      if (ptr_)
-        allocator_.deallocate(ptr_, 1);
-    }
-  private:
-    // Disallow copying and assignment.
-    raw_mem(const raw_mem&);
-    raw_mem operator=(const raw_mem&);
-  };
-};
-// Polymorphic executor specialisation for system_executor.
-template <typename Allocator>
-class executor::impl<system_executor, Allocator>
-  : public executor::impl_base
-{
-public:
-  static impl_base* create(const system_executor&,
-      const Allocator& = Allocator())
-  {
-    return &detail::global<impl<system_executor, std::allocator<void> > >();
-  }
-  impl()
-    : impl_base(true)
-  {
-  }
-  impl_base* clone() const ASIO_NOEXCEPT
-  {
-    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
-  }
-  void destroy() ASIO_NOEXCEPT
-  {
-  }
-  void on_work_started() ASIO_NOEXCEPT
-  {
-    executor_.on_work_started();
-  }
-  void on_work_finished() ASIO_NOEXCEPT
-  {
-    executor_.on_work_finished();
-  }
-  execution_context& context() ASIO_NOEXCEPT
-  {
-    return executor_.context();
-  }
-  void dispatch(ASIO_MOVE_ARG(function) f)
-  {
-    executor_.dispatch(ASIO_MOVE_CAST(function)(f),
-        std::allocator<void>());
-  }
-  void post(ASIO_MOVE_ARG(function) f)
-  {
-    executor_.post(ASIO_MOVE_CAST(function)(f),
-        std::allocator<void>());
-  }
-  void defer(ASIO_MOVE_ARG(function) f)
-  {
-    executor_.defer(ASIO_MOVE_CAST(function)(f),
-        std::allocator<void>());
-  }
-  type_id_result_type target_type() const ASIO_NOEXCEPT
-  {
-    return type_id<system_executor>();
-  }
-  void* target() ASIO_NOEXCEPT
-  {
-    return &executor_;
-  }
-  const void* target() const ASIO_NOEXCEPT
-  {
-    return &executor_;
-  }
-  bool equals(const impl_base* e) const ASIO_NOEXCEPT
-  {
-    return this == e;
-  }
-private:
-  system_executor executor_;
-};
-template <typename Executor>
-executor::executor(Executor e)
-  : impl_(impl<Executor, std::allocator<void> >::create(e))
-{
-}
-template <typename Executor, typename Allocator>
-executor::executor(allocator_arg_t, const Allocator& a, Executor e)
-  : impl_(impl<Executor, Allocator>::create(e, a))
-{
-}
-template <typename Function, typename Allocator>
-void executor::dispatch(ASIO_MOVE_ARG(Function) f,
-    const Allocator& a) const
-{
-  impl_base* i = get_impl();
-  if (i->fast_dispatch_)
-    system_executor().dispatch(ASIO_MOVE_CAST(Function)(f), a);
-  else
-    i->dispatch(function(ASIO_MOVE_CAST(Function)(f), a));
-}
-template <typename Function, typename Allocator>
-void executor::post(ASIO_MOVE_ARG(Function) f,
-    const Allocator& a) const
-{
-  get_impl()->post(function(ASIO_MOVE_CAST(Function)(f), a));
-}
-template <typename Function, typename Allocator>
-void executor::defer(ASIO_MOVE_ARG(Function) f,
-    const Allocator& a) const
-{
-  get_impl()->defer(function(ASIO_MOVE_CAST(Function)(f), a));
-}
-template <typename Executor>
-Executor* executor::target() ASIO_NOEXCEPT
-{
-  return impl_ && impl_->target_type() == type_id<Executor>()
-    ? static_cast<Executor*>(impl_->target()) : 0;
-}
-template <typename Executor>
-const Executor* executor::target() const ASIO_NOEXCEPT
-{
-  return impl_ && impl_->target_type() == type_id<Executor>()
-    ? static_cast<Executor*>(impl_->target()) : 0;
-}
-#endif // !defined(GENERATING_DOCUMENTATION)
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-#endif // ASIO_IMPL_EXECUTOR_HPP

data/ext/third_party/asio/asio/include/asio/impl/executor.ipp DELETED

@@ -1,43 +0,0 @@
-//
-// impl/executor.ipp
-// ~~~~~~~~~~~~~~~~~
-//
-// 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)
-//
-#ifndef ASIO_IMPL_EXECUTOR_IPP
-#define ASIO_IMPL_EXECUTOR_IPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#if !defined(ASIO_NO_TS_EXECUTORS)
-#include "asio/executor.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-bad_executor::bad_executor() ASIO_NOEXCEPT
-{
-}
-const char* bad_executor::what() const ASIO_NOEXCEPT_OR_NOTHROW
-{
-  return "bad executor";
-}
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-#endif // ASIO_IMPL_EXECUTOR_IPP

data/ext/third_party/asio/asio/include/asio/impl/handler_alloc_hook.ipp DELETED

@@ -1,61 +0,0 @@
-//
-// impl/handler_alloc_hook.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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)
-//
-#ifndef ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
-#define ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#include "asio/detail/thread_context.hpp"
-#include "asio/detail/thread_info_base.hpp"
-#include "asio/handler_alloc_hook.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-asio_handler_allocate_is_deprecated
-asio_handler_allocate(std::size_t size, ...)
-{
-#if defined(ASIO_NO_DEPRECATED)
-  (void)size;
-  return asio_handler_allocate_is_no_longer_used();
-#elif !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  return detail::thread_info_base::allocate(
-      detail::thread_context::thread_call_stack::top(), size);
-#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  return ::operator new(size);
-#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-}
-asio_handler_deallocate_is_deprecated
-asio_handler_deallocate(void* pointer, std::size_t size, ...)
-{
-#if defined(ASIO_NO_DEPRECATED)
-  (void)pointer;
-  (void)size;
-  return asio_handler_deallocate_is_no_longer_used();
-#elif !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  detail::thread_info_base::deallocate(
-      detail::thread_context::thread_call_stack::top(), pointer, size);
-#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  (void)size;
-  ::operator delete(pointer);
-#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-}
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP

data/ext/third_party/asio/asio/include/asio/impl/io_context.hpp DELETED

@@ -1,440 +0,0 @@
-//
-// impl/io_context.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// 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)
-//
-#ifndef ASIO_IMPL_IO_CONTEXT_HPP
-#define ASIO_IMPL_IO_CONTEXT_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/detail/service_registry.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename Service>
-inline Service& use_service(io_context& ioc)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
-  (void)static_cast<const execution_context::id*>(&Service::id);
-  return ioc.service_registry_->template use_service<Service>(ioc);
-}
-template <>
-inline detail::io_context_impl& use_service<detail::io_context_impl>(
-    io_context& ioc)
-{
-  return ioc.impl_;
-}
-#endif // !defined(GENERATING_DOCUMENTATION)
-inline io_context::executor_type
-io_context::get_executor() ASIO_NOEXCEPT
-{
-  return executor_type(*this);
-}
-#if defined(ASIO_HAS_CHRONO)
-template <typename Rep, typename Period>
-std::size_t io_context::run_for(
-    const chrono::duration<Rep, Period>& rel_time)
-{
-  return this->run_until(chrono::steady_clock::now() + rel_time);
-}
-template <typename Clock, typename Duration>
-std::size_t io_context::run_until(
-    const chrono::time_point<Clock, Duration>& abs_time)
-{
-  std::size_t n = 0;
-  while (this->run_one_until(abs_time))
-    if (n != (std::numeric_limits<std::size_t>::max)())
-      ++n;
-  return n;
-}
-template <typename Rep, typename Period>
-std::size_t io_context::run_one_for(
-    const chrono::duration<Rep, Period>& rel_time)
-{
-  return this->run_one_until(chrono::steady_clock::now() + rel_time);
-}
-template <typename Clock, typename Duration>
-std::size_t io_context::run_one_until(
-    const chrono::time_point<Clock, Duration>& abs_time)
-{
-  typename Clock::time_point now = Clock::now();
-  while (now < abs_time)
-  {
-    typename Clock::duration rel_time = abs_time - now;
-    if (rel_time > chrono::seconds(1))
-      rel_time = chrono::seconds(1);
-    asio::error_code ec;
-    std::size_t s = impl_.wait_one(
-        static_cast<long>(chrono::duration_cast<
-          chrono::microseconds>(rel_time).count()), ec);
-    asio::detail::throw_error(ec);
-    if (s || impl_.stopped())
-      return s;
-    now = Clock::now();
-  }
-  return 0;
-}
-#endif // defined(ASIO_HAS_CHRONO)
-#if !defined(ASIO_NO_DEPRECATED)
-inline void io_context::reset()
-{
-  restart();
-}
-struct io_context::initiate_dispatch
-{
-  template <typename LegacyCompletionHandler>
-  void operator()(ASIO_MOVE_ARG(LegacyCompletionHandler) handler,
-      io_context* self) const
-  {
-    // If you get an error on the following line it means that your handler does
-    // not meet the documented type requirements for a LegacyCompletionHandler.
-    ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
-        LegacyCompletionHandler, handler) type_check;
-    detail::non_const_lvalue<LegacyCompletionHandler> handler2(handler);
-    if (self->impl_.can_dispatch())
-    {
-      detail::fenced_block b(detail::fenced_block::full);
-      asio_handler_invoke_helpers::invoke(
-          handler2.value, handler2.value);
-    }
-    else
-    {
-      // Allocate and construct an operation to wrap the handler.
-      typedef detail::completion_handler<
-        typename decay<LegacyCompletionHandler>::type, executor_type> op;
-      typename op::ptr p = { detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-      p.p = new (p.v) op(handler2.value, self->get_executor());
-      ASIO_HANDLER_CREATION((*self, *p.p,
-            "io_context", self, 0, "dispatch"));
-      self->impl_.do_dispatch(p.p);
-      p.v = p.p = 0;
-    }
-  }
-};
-template <typename LegacyCompletionHandler>
-ASIO_INITFN_AUTO_RESULT_TYPE(LegacyCompletionHandler, void ())
-io_context::dispatch(ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
-{
-  return async_initiate<LegacyCompletionHandler, void ()>(
-      initiate_dispatch(), handler, this);
-}
-struct io_context::initiate_post
-{
-  template <typename LegacyCompletionHandler>
-  void operator()(ASIO_MOVE_ARG(LegacyCompletionHandler) handler,
-      io_context* self) const
-  {
-    // If you get an error on the following line it means that your handler does
-    // not meet the documented type requirements for a LegacyCompletionHandler.
-    ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
-        LegacyCompletionHandler, handler) type_check;
-    detail::non_const_lvalue<LegacyCompletionHandler> handler2(handler);
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler2.value);
-    // Allocate and construct an operation to wrap the handler.
-    typedef detail::completion_handler<
-      typename decay<LegacyCompletionHandler>::type, executor_type> op;
-    typename op::ptr p = { detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    p.p = new (p.v) op(handler2.value, self->get_executor());
-    ASIO_HANDLER_CREATION((*self, *p.p,
-          "io_context", self, 0, "post"));
-    self->impl_.post_immediate_completion(p.p, is_continuation);
-    p.v = p.p = 0;
-  }
-};
-template <typename LegacyCompletionHandler>
-ASIO_INITFN_AUTO_RESULT_TYPE(LegacyCompletionHandler, void ())
-io_context::post(ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
-{
-  return async_initiate<LegacyCompletionHandler, void ()>(
-      initiate_post(), handler, this);
-}
-template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-unspecified
-#else
-inline detail::wrapped_handler<io_context&, Handler>
-#endif
-io_context::wrap(Handler handler)
-{
-  return detail::wrapped_handler<io_context&, Handler>(*this, handler);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-template <typename Allocator, unsigned int Bits>
-io_context::basic_executor_type<Allocator, Bits>&
-io_context::basic_executor_type<Allocator, Bits>::operator=(
-    const basic_executor_type& other) ASIO_NOEXCEPT
-{
-  if (this != &other)
-  {
-    io_context* old_io_context = io_context_;
-    io_context_ = other.io_context_;
-    allocator_ = other.allocator_;
-    bits_ = other.bits_;
-    if (Bits & outstanding_work_tracked)
-    {
-      if (io_context_)
-        io_context_->impl_.work_started();
-      if (old_io_context)
-        old_io_context->impl_.work_finished();
-    }
-  }
-  return *this;
-}
-#if defined(ASIO_HAS_MOVE)
-template <typename Allocator, unsigned int Bits>
-io_context::basic_executor_type<Allocator, Bits>&
-io_context::basic_executor_type<Allocator, Bits>::operator=(
-    basic_executor_type&& other) ASIO_NOEXCEPT
-{
-  if (this != &other)
-  {
-    io_context_ = other.io_context_;
-    allocator_ = std::move(other.allocator_);
-    bits_ = other.bits_;
-    if (Bits & outstanding_work_tracked)
-      other.io_context_ = 0;
-  }
-  return *this;
-}
-#endif // defined(ASIO_HAS_MOVE)
-template <typename Allocator, unsigned int Bits>
-inline bool io_context::basic_executor_type<Allocator,
-    Bits>::running_in_this_thread() const ASIO_NOEXCEPT
-{
-  return io_context_->impl_.can_dispatch();
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void io_context::basic_executor_type<Allocator, Bits>::execute(
-    ASIO_MOVE_ARG(Function) f) 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 && io_context_->impl_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(ASIO_MOVE_CAST(Function)(f));
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       //   && !defined(ASIO_NO_EXCEPTIONS)
-      detail::fenced_block b(detail::fenced_block::full);
-      asio_handler_invoke_helpers::invoke(tmp, tmp);
-      return;
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      io_context_->impl_.capture_current_exception();
-      return;
-    }
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       //   && !defined(ASIO_NO_EXCEPTIONS)
-  }
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(allocator_),
-      op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), allocator_);
-  ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "execute"));
-  io_context_->impl_.post_immediate_completion(p.p,
-      (bits_ & relationship_continuation) != 0);
-  p.v = p.p = 0;
-}
-#if !defined(ASIO_NO_TS_EXECUTORS)
-template <typename Allocator, unsigned int Bits>
-inline io_context& io_context::basic_executor_type<
-    Allocator, Bits>::context() const ASIO_NOEXCEPT
-{
-  return *io_context_;
-}
-template <typename Allocator, unsigned int Bits>
-inline void io_context::basic_executor_type<Allocator,
-    Bits>::on_work_started() const ASIO_NOEXCEPT
-{
-  io_context_->impl_.work_started();
-}
-template <typename Allocator, unsigned int Bits>
-inline void io_context::basic_executor_type<Allocator,
-    Bits>::on_work_finished() const ASIO_NOEXCEPT
-{
-  io_context_->impl_.work_finished();
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void io_context::basic_executor_type<Allocator, Bits>::dispatch(
-    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 (io_context_->impl_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(ASIO_MOVE_CAST(Function)(f));
-    detail::fenced_block b(detail::fenced_block::full);
-    asio_handler_invoke_helpers::invoke(tmp, tmp);
-    return;
-  }
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type,
-      OtherAllocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
-  ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "dispatch"));
-  io_context_->impl_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void io_context::basic_executor_type<Allocator, Bits>::post(
-    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,
-      OtherAllocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
-  ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "post"));
-  io_context_->impl_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void io_context::basic_executor_type<Allocator, Bits>::defer(
-    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,
-      OtherAllocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
-  ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "defer"));
-  io_context_->impl_.post_immediate_completion(p.p, true);
-  p.v = p.p = 0;
-}
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-#if !defined(ASIO_NO_DEPRECATED)
-inline io_context::work::work(asio::io_context& io_context)
-  : io_context_impl_(io_context.impl_)
-{
-  io_context_impl_.work_started();
-}
-inline io_context::work::work(const work& other)
-  : io_context_impl_(other.io_context_impl_)
-{
-  io_context_impl_.work_started();
-}
-inline io_context::work::~work()
-{
-  io_context_impl_.work_finished();
-}
-inline asio::io_context& io_context::work::get_io_context()
-{
-  return static_cast<asio::io_context&>(io_context_impl_.context());
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-inline asio::io_context& io_context::service::get_io_context()
-{
-  return static_cast<asio::io_context&>(context());
-}
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_IMPL_IO_CONTEXT_HPP