couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/asio/asio/include/asio/detail/handler_alloc_helpers.hpp

@@ -19,6 +19,7 @@
 #include "asio/detail/memory.hpp"
 #include "asio/detail/noncopyable.hpp"
 #include "asio/detail/recycling_allocator.hpp"
+#include "asio/detail/thread_info_base.hpp"
 #include "asio/associated_allocator.hpp"
 #include "asio/handler_alloc_hook.hpp"
 
@@ -29,11 +30,41 @@
 // asio_handler_alloc_helpers namespace is defined here for that purpose.
 namespace asio_handler_alloc_helpers {
 
+#if defined(ASIO_NO_DEPRECATED)
+template <typename Handler>
+inline void error_if_hooks_are_defined(Handler& h)
+{
+  using asio::asio_handler_allocate;
+  // If you get an error here it is because some of your handlers still
+  // overload asio_handler_allocate, but this hook is no longer used.
+  (void)static_cast<asio::asio_handler_allocate_is_no_longer_used>(
+    asio_handler_allocate(static_cast<std::size_t>(0),
+      asio::detail::addressof(h)));
+
+  using asio::asio_handler_deallocate;
+  // If you get an error here it is because some of your handlers still
+  // overload asio_handler_deallocate, but this hook is no longer used.
+  (void)static_cast<asio::asio_handler_deallocate_is_no_longer_used>(
+    asio_handler_deallocate(static_cast<void*>(0),
+      static_cast<std::size_t>(0), asio::detail::addressof(h)));
+}
+#endif // defined(ASIO_NO_DEPRECATED)
+
 template <typename Handler>
 inline void* allocate(std::size_t s, Handler& h)
 {
 #if !defined(ASIO_HAS_HANDLER_HOOKS)
   return ::operator new(s);
+#elif defined(ASIO_NO_DEPRECATED)
+  // The asio_handler_allocate hook is no longer used to obtain memory.
+  (void)&error_if_hooks_are_defined<Handler>;
+  (void)h;
+#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  return asio::detail::thread_info_base::allocate(
+      asio::detail::thread_context::thread_call_stack::top(), s);
+#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  return ::operator new(size);
+#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 #else
   using asio::asio_handler_allocate;
   return asio_handler_allocate(s, asio::detail::addressof(h));
@@ -45,6 +76,17 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
 {
 #if !defined(ASIO_HAS_HANDLER_HOOKS)
   ::operator delete(p);
+#elif defined(ASIO_NO_DEPRECATED)
+  // The asio_handler_allocate hook is no longer used to obtain memory.
+  (void)&error_if_hooks_are_defined<Handler>;
+  (void)h;
+#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  asio::detail::thread_info_base::deallocate(
+      asio::detail::thread_context::thread_call_stack::top(), p, s);
+#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  (void)s;
+  ::operator delete(p);
+#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 #else
   using asio::asio_handler_deallocate;
   asio_handler_deallocate(p, s, asio::detail::addressof(h));

data/ext/third_party/asio/asio/include/asio/detail/handler_invoke_helpers.hpp

@@ -26,12 +26,29 @@
 // namespace is defined here for that purpose.
 namespace asio_handler_invoke_helpers {
 
+#if defined(ASIO_NO_DEPRECATED)
+template <typename Function, typename Context>
+inline void error_if_hook_is_defined(Function& function, Context& context)
+{
+  using asio::asio_handler_invoke;
+  // If you get an error here it is because some of your handlers still
+  // overload asio_handler_invoke, but this hook is no longer used.
+  (void)static_cast<asio::asio_handler_invoke_is_no_longer_used>(
+    asio_handler_invoke(function, asio::detail::addressof(context)));
+}
+#endif // defined(ASIO_NO_DEPRECATED)
+
 template <typename Function, typename Context>
 inline void invoke(Function& function, Context& context)
 {
 #if !defined(ASIO_HAS_HANDLER_HOOKS)
   Function tmp(function);
   tmp();
+#elif defined(ASIO_NO_DEPRECATED)
+  // The asio_handler_invoke hook is no longer used to invoke the function.
+  (void)&error_if_hook_is_defined<Function, Context>;
+  (void)context;
+  function();
 #else
   using asio::asio_handler_invoke;
   asio_handler_invoke(function, asio::detail::addressof(context));
@@ -44,6 +61,12 @@ inline void invoke(const Function& function, Context& context)
 #if !defined(ASIO_HAS_HANDLER_HOOKS)
   Function tmp(function);
   tmp();
+#elif defined(ASIO_NO_DEPRECATED)
+  // The asio_handler_invoke hook is no longer used to invoke the function.
+  (void)&error_if_hook_is_defined<const Function, Context>;
+  (void)context;
+  Function tmp(function);
+  tmp();
 #else
   using asio::asio_handler_invoke;
   asio_handler_invoke(function, asio::detail::addressof(context));

data/ext/third_party/asio/asio/include/asio/detail/handler_tracking.hpp

@@ -87,6 +87,28 @@ public:
   // Initialise the tracking system.
   ASIO_DECL static void init();
 
+  class location
+  {
+  public:
+    // Constructor adds a location to the stack.
+    ASIO_DECL explicit location(const char* file,
+        int line, const char* func);
+
+    // Destructor removes a location from the stack.
+    ASIO_DECL ~location();
+
+  private:
+    // Disallow copying and assignment.
+    location(const location&) ASIO_DELETED;
+    location& operator=(const location&) ASIO_DELETED;
+
+    friend class handler_tracking;
+    const char* file_;
+    int line_;
+    const char* func_;
+    location* next_;
+  };
+
   // Record the creation of a tracked handler.
   ASIO_DECL static void creation(
       execution_context& context, tracked_handler& h,
@@ -175,6 +197,9 @@ private:
 # define ASIO_HANDLER_TRACKING_INIT \
   asio::detail::handler_tracking::init()
 
+# define ASIO_HANDLER_LOCATION(args) \
+  asio::detail::handler_tracking::location tracked_location args
+
 # define ASIO_HANDLER_CREATION(args) \
   asio::detail::handler_tracking::creation args
 
@@ -211,6 +236,7 @@ private:
 # define ASIO_INHERIT_TRACKED_HANDLER
 # define ASIO_ALSO_INHERIT_TRACKED_HANDLER
 # define ASIO_HANDLER_TRACKING_INIT (void)0
+# define ASIO_HANDLER_LOCATION(loc) (void)0
 # define ASIO_HANDLER_CREATION(args) (void)0
 # define ASIO_HANDLER_COMPLETION(args) (void)0
 # define ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0

data/ext/third_party/asio/asio/include/asio/detail/handler_work.hpp

@@ -18,91 +18,416 @@
 #include "asio/detail/config.hpp"
 #include "asio/associated_executor.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution/allocator.hpp"
+#include "asio/execution/blocking.hpp"
+#include "asio/execution/execute.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/outstanding_work.hpp"
+#include "asio/executor_work_guard.hpp"
+#include "asio/prefer.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
+
+class executor;
+class io_context;
+
+namespace execution {
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename...> class any_executor;
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename, typename, typename, typename, typename,
+    typename, typename, typename, typename> class any_executor;
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+} // namespace execution
 namespace detail {
 
-// A helper class template to allow completion handlers to be dispatched
-// through either the new executors framework or the old invocaton hook. The
-// primary template uses the new executors framework.
-template <typename Handler,
-    typename IoExecutor = system_executor, typename HandlerExecutor
-      = typename associated_executor<Handler, IoExecutor>::type>
-class handler_work
+template <typename Executor, typename CandidateExecutor = void,
+    typename IoContext = io_context,
+    typename PolymorphicExecutor = executor, typename = void>
+class handler_work_base
 {
 public:
-  explicit handler_work(Handler& handler) ASIO_NOEXCEPT
-    : io_executor_(),
-      executor_(asio::get_associated_executor(handler, io_executor_))
+  explicit handler_work_base(const Executor& ex) ASIO_NOEXCEPT
+    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
 
-  handler_work(Handler& handler, const IoExecutor& io_ex) ASIO_NOEXCEPT
-    : io_executor_(io_ex),
-      executor_(asio::get_associated_executor(handler, io_executor_))
+  template <typename OtherExecutor>
+  handler_work_base(const Executor& ex,
+      const OtherExecutor&) ASIO_NOEXCEPT
+    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
 
-  static void start(Handler& handler) ASIO_NOEXCEPT
+  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
+    : executor_(other.executor_)
   {
-    HandlerExecutor ex(asio::get_associated_executor(handler));
-    ex.on_work_started();
   }
 
-  static void start(Handler& handler,
-      const IoExecutor& io_ex) ASIO_NOEXCEPT
+#if defined(ASIO_HAS_MOVE)
+  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(executor_type)(other.executor_))
   {
-    HandlerExecutor ex(asio::get_associated_executor(handler, io_ex));
-    ex.on_work_started();
-    io_ex.on_work_started();
   }
+#endif // defined(ASIO_HAS_MOVE)
 
-  ~handler_work()
+  bool owns_work() const ASIO_NOEXCEPT
   {
-    io_executor_.on_work_finished();
-    executor_.on_work_finished();
+    return true;
   }
 
-  template <typename Function>
-  void complete(Function& function, Handler& handler)
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
+  {
+    execution::execute(
+        asio::prefer(executor_,
+          execution::blocking.possibly,
+          execution::allocator((get_associated_allocator)(handler))),
+        ASIO_MOVE_CAST(Function)(function));
+  }
+
+private:
+  typedef typename decay<
+      typename prefer_result<Executor,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  executor_type executor_;
+};
+
+template <typename Executor, typename CandidateExecutor,
+    typename IoContext, typename PolymorphicExecutor>
+class handler_work_base<Executor, CandidateExecutor,
+    IoContext, PolymorphicExecutor,
+    typename enable_if<
+      !execution::is_executor<Executor>::value
+        && (!is_same<Executor, PolymorphicExecutor>::value
+          || !is_same<CandidateExecutor, void>::value)
+    >::type>
+{
+public:
+  explicit handler_work_base(const Executor& ex) ASIO_NOEXCEPT
+    : executor_(ex),
+      owns_work_(true)
+  {
+    executor_.on_work_started();
+  }
+
+  handler_work_base(const Executor& ex,
+      const Executor& candidate) ASIO_NOEXCEPT
+    : executor_(ex),
+      owns_work_(ex != candidate)
+  {
+    if (owns_work_)
+      executor_.on_work_started();
+  }
+
+  template <typename OtherExecutor>
+  handler_work_base(const Executor& ex,
+      const OtherExecutor&) ASIO_NOEXCEPT
+    : executor_(ex),
+      owns_work_(true)
+  {
+    executor_.on_work_started();
+  }
+
+  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
+    : executor_(other.executor_),
+      owns_work_(other.owns_work_)
+  {
+    if (owns_work_)
+      executor_.on_work_started();
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_)),
+      owns_work_(other.owns_work_)
+  {
+    other.owns_work_ = false;
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  ~handler_work_base()
+  {
+    if (owns_work_)
+      executor_.on_work_finished();
+  }
+
+  bool owns_work() const ASIO_NOEXCEPT
+  {
+    return owns_work_;
+  }
+
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
+  {
+    executor_.dispatch(ASIO_MOVE_CAST(Function)(function),
+        asio::get_associated_allocator(handler));
+  }
+
+private:
+  Executor executor_;
+  bool owns_work_;
+};
+
+template <typename Executor, typename IoContext, typename PolymorphicExecutor>
+class handler_work_base<Executor, void, IoContext, PolymorphicExecutor,
+    typename enable_if<
+      is_same<
+        Executor,
+        typename IoContext::executor_type
+      >::value
+    >::type>
+{
+public:
+  explicit handler_work_base(const Executor&)
+  {
+  }
+
+  bool owns_work() const ASIO_NOEXCEPT
+  {
+    return false;
+  }
+
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
+  {
+    // When using a native implementation, I/O completion handlers are
+    // already dispatched according to the execution context's executor's
+    // rules. We can call the function directly.
+    asio_handler_invoke_helpers::invoke(function, handler);
+  }
+};
+
+template <typename Executor, typename IoContext>
+class handler_work_base<Executor, void, IoContext, Executor>
+{
+public:
+  explicit handler_work_base(const Executor& ex) ASIO_NOEXCEPT
+#if !defined(ASIO_NO_TYPEID)
+    : executor_(
+        ex.target_type() == typeid(typename IoContext::executor_type)
+          ? Executor() : ex)
+#else // !defined(ASIO_NO_TYPEID)
+    : executor_(ex)
+#endif // !defined(ASIO_NO_TYPEID)
+  {
+    if (executor_)
+      executor_.on_work_started();
+  }
+
+  handler_work_base(const Executor& ex,
+      const Executor& candidate) ASIO_NOEXCEPT
+    : executor_(ex != candidate ? ex : Executor())
+  {
+    if (executor_)
+      executor_.on_work_started();
+  }
+
+  template <typename OtherExecutor>
+  handler_work_base(const Executor& ex,
+      const OtherExecutor&) ASIO_NOEXCEPT
+    : executor_(ex)
+  {
+    executor_.on_work_started();
+  }
+
+  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
+    : executor_(other.executor_)
+  {
+    if (executor_)
+      executor_.on_work_started();
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  ~handler_work_base()
+  {
+    if (executor_)
+      executor_.on_work_finished();
+  }
+
+  bool owns_work() const ASIO_NOEXCEPT
+  {
+    return !!executor_;
+  }
+
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
   {
     executor_.dispatch(ASIO_MOVE_CAST(Function)(function),
         asio::get_associated_allocator(handler));
   }
 
 private:
-  // Disallow copying and assignment.
-  handler_work(const handler_work&);
-  handler_work& operator=(const handler_work&);
+  Executor executor_;
+};
+
+template <
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    typename... SupportableProperties,
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9,
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    typename IoContext, typename PolymorphicExecutor>
+class handler_work_base<
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    execution::any_executor<SupportableProperties...>,
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9>,
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    void, IoContext, PolymorphicExecutor>
+{
+public:
+  typedef
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    execution::any_executor<SupportableProperties...>
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9>
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+    executor_type;
+
+  explicit handler_work_base(const executor_type& ex) ASIO_NOEXCEPT
+#if !defined(ASIO_NO_TYPEID)
+    : executor_(
+        ex.target_type() == typeid(typename IoContext::executor_type)
+          ? executor_type()
+          : asio::prefer(ex, execution::outstanding_work.tracked))
+#else // !defined(ASIO_NO_TYPEID)
+    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
+#endif // !defined(ASIO_NO_TYPEID)
+  {
+  }
+
+  handler_work_base(const executor_type& ex,
+      const executor_type& candidate) ASIO_NOEXCEPT
+    : executor_(ex != candidate ? ex : executor_type())
+  {
+  }
+
+  template <typename OtherExecutor>
+  handler_work_base(const executor_type& ex,
+      const OtherExecutor&) ASIO_NOEXCEPT
+    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
+    : executor_(other.executor_)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(executor_type)(other.executor_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
 
-  IoExecutor io_executor_;
-  HandlerExecutor executor_;
+  bool owns_work() const ASIO_NOEXCEPT
+  {
+    return !!executor_;
+  }
+
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
+  {
+    execution::execute(
+        asio::prefer(executor_,
+          execution::blocking.possibly,
+          execution::allocator((get_associated_allocator)(handler))),
+        ASIO_MOVE_CAST(Function)(function));
+  }
+
+private:
+  executor_type executor_;
 };
 
-// This specialisation dispatches a handler through the old invocation hook.
-// The specialisation is not strictly required for correctness, as the
-// system_executor will dispatch through the hook anyway. However, by doing
-// this we avoid an extra copy of the handler.
-template <typename Handler>
-class handler_work<Handler, system_executor, system_executor>
+template <typename Handler, typename IoExecutor, typename = void>
+class handler_work :
+  handler_work_base<IoExecutor>,
+  handler_work_base<typename associated_executor<
+      Handler, IoExecutor>::type, IoExecutor>
 {
 public:
-  explicit handler_work(Handler&) ASIO_NOEXCEPT {}
-  static void start(Handler&) ASIO_NOEXCEPT {}
-  ~handler_work() {}
+  typedef handler_work_base<IoExecutor> base1_type;
+  typedef handler_work_base<typename associated_executor<
+    Handler, IoExecutor>::type, IoExecutor> base2_type;
+
+  handler_work(Handler& handler, const IoExecutor& io_ex) ASIO_NOEXCEPT
+    : base1_type(io_ex),
+      base2_type(asio::get_associated_executor(handler, io_ex), io_ex)
+  {
+  }
 
   template <typename Function>
   void complete(Function& function, Handler& handler)
   {
-    asio_handler_invoke_helpers::invoke(function, handler);
+    if (!base1_type::owns_work() && !base2_type::owns_work())
+    {
+      // When using a native implementation, I/O completion handlers are
+      // already dispatched according to the execution context's executor's
+      // rules. We can call the function directly.
+      asio_handler_invoke_helpers::invoke(function, handler);
+    }
+    else
+    {
+      base2_type::dispatch(function, handler);
+    }
   }
+};
 
-private:
-  // Disallow copying and assignment.
-  handler_work(const handler_work&);
-  handler_work& operator=(const handler_work&);
+template <typename Handler, typename IoExecutor>
+class handler_work<
+    Handler, IoExecutor,
+    typename enable_if<
+      is_same<
+        typename associated_executor<Handler,
+          IoExecutor>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type> : handler_work_base<IoExecutor>
+{
+public:
+  typedef handler_work_base<IoExecutor> base1_type;
+
+  handler_work(Handler&, const IoExecutor& io_ex) ASIO_NOEXCEPT
+    : base1_type(io_ex)
+  {
+  }
+
+  template <typename Function>
+  void complete(Function& function, Handler& handler)
+  {
+    if (!base1_type::owns_work())
+    {
+      // When using a native implementation, I/O completion handlers are
+      // already dispatched according to the execution context's executor's
+      // rules. We can call the function directly.
+      asio_handler_invoke_helpers::invoke(function, handler);
+    }
+    else
+    {
+      base1_type::dispatch(function, handler);
+    }
+  }
 };
 
 } // namespace detail