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

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

@@ -23,6 +23,7 @@
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/ip/basic_resolver_results.hpp"
@@ -54,9 +55,8 @@ public:
             &winrt_resolve_op::do_complete),
       query_(query),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -65,10 +65,14 @@ public:
     // Take ownership of the operation object.
     winrt_resolve_op* o(static_cast<winrt_resolve_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
     results_type results = results_type();
     if (!o->ec_)
     {
@@ -108,7 +112,7 @@ public:
 private:
   query_type query_;
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> executor_;
 };
 
 } // namespace detail

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

@@ -24,6 +24,7 @@
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
@@ -43,9 +44,8 @@ public:
   winrt_socket_connect_op(Handler& handler, const IoExecutor& io_ex)
     : winrt_async_op<void>(&winrt_socket_connect_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -54,10 +54,14 @@ public:
     // Take ownership of the operation object.
     winrt_socket_connect_op* o(static_cast<winrt_socket_connect_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -81,7 +85,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> executor_;
 };
 
 } // namespace detail

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

@@ -24,6 +24,7 @@
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
@@ -46,9 +47,8 @@ public:
           &winrt_socket_recv_op::do_complete),
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -57,10 +57,14 @@ public:
     // Take ownership of the operation object.
     winrt_socket_recv_op* o(static_cast<winrt_socket_recv_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -102,7 +106,7 @@ public:
 private:
   MutableBufferSequence buffers_;
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> executor_;
 };
 
 } // namespace detail

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

@@ -24,6 +24,7 @@
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/winrt_async_op.hpp"
 #include "asio/error.hpp"
@@ -45,9 +46,8 @@ public:
     : winrt_async_op<unsigned int>(&winrt_socket_send_op::do_complete),
       buffers_(buffers),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -56,10 +56,14 @@ public:
     // Take ownership of the operation object.
     winrt_socket_send_op* o(static_cast<winrt_socket_send_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
 #if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -93,7 +97,7 @@ public:
 private:
   ConstBufferSequence buffers_;
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> executor_;
 };
 
 } // namespace detail

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

@@ -16,22 +16,96 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
 #include "asio/associated_executor.hpp"
 #include "asio/associated_allocator.hpp"
 #include "asio/executor_work_guard.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/allocator.hpp"
+#include "asio/execution/blocking.hpp"
+#include "asio/execution/outstanding_work.hpp"
+#include "asio/prefer.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-template <typename Handler>
+template <typename Handler, typename Executor, typename = void>
+struct is_work_dispatcher_required : true_type
+{
+};
+
+template <typename Handler, typename Executor>
+struct is_work_dispatcher_required<Handler, Executor,
+    typename enable_if<
+      is_same<
+        typename associated_executor<Handler,
+          Executor>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type> : false_type
+{
+};
+
+template <typename Handler, typename Executor, typename = void>
 class work_dispatcher
 {
 public:
   template <typename CompletionHandler>
-  explicit work_dispatcher(ASIO_MOVE_ARG(CompletionHandler) handler)
-    : work_((get_associated_executor)(handler)),
+  work_dispatcher(ASIO_MOVE_ARG(CompletionHandler) handler,
+      const Executor& handler_ex)
+    : handler_(ASIO_MOVE_CAST(CompletionHandler)(handler)),
+      executor_(asio::prefer(handler_ex,
+          execution::outstanding_work.tracked))
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  work_dispatcher(const work_dispatcher& other)
+    : handler_(other.handler_),
+      executor_(other.executor_)
+  {
+  }
+
+  work_dispatcher(work_dispatcher&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      executor_(ASIO_MOVE_CAST(work_executor_type)(other.executor_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    execution::execute(
+        asio::prefer(executor_,
+          execution::blocking.possibly,
+          execution::allocator((get_associated_allocator)(handler_))),
+        ASIO_MOVE_CAST(Handler)(handler_));
+  }
+
+private:
+  typedef typename decay<
+      typename prefer_result<const Executor&,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type work_executor_type;
+
+  Handler handler_;
+  work_executor_type executor_;
+};
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Handler, typename Executor>
+class work_dispatcher<Handler, Executor,
+    typename enable_if<!execution::is_executor<Executor>::value>::type>
+{
+public:
+  template <typename CompletionHandler>
+  work_dispatcher(ASIO_MOVE_ARG(CompletionHandler) handler,
+      const Executor& handler_ex)
+    : work_(handler_ex),
       handler_(ASIO_MOVE_CAST(CompletionHandler)(handler))
   {
   }
@@ -44,8 +118,7 @@ public:
   }
 
   work_dispatcher(work_dispatcher&& other)
-    : work_(ASIO_MOVE_CAST(executor_work_guard<
-        typename associated_executor<Handler>::type>)(other.work_)),
+    : work_(ASIO_MOVE_CAST(executor_work_guard<Executor>)(other.work_)),
       handler_(ASIO_MOVE_CAST(Handler)(other.handler_))
   {
   }
@@ -61,10 +134,12 @@ public:
   }
 
 private:
-  executor_work_guard<typename associated_executor<Handler>::type> work_;
+  executor_work_guard<Executor> work_;
   Handler handler_;
 };
 
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
 } // namespace detail
 } // namespace asio
 

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

@@ -201,19 +201,29 @@ public:
 };
 
 template <typename Dispatcher, typename Handler, typename IsContinuation>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
+#if defined(ASIO_NO_DEPRECATED)
+  asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
   return asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Dispatcher, typename Handler, typename IsContinuation>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Dispatcher, typename Handler, typename IsContinuation>
@@ -225,38 +235,56 @@ inline bool asio_handler_is_continuation(
 
 template <typename Function, typename Dispatcher,
     typename Handler, typename IsContinuation>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   this_handler->dispatcher_.dispatch(
       rewrapped_handler<Function, Handler>(
         function, this_handler->handler_));
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Dispatcher,
     typename Handler, typename IsContinuation>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   this_handler->dispatcher_.dispatch(
       rewrapped_handler<Function, Handler>(
         function, this_handler->handler_));
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Context>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     rewrapped_handler<Handler, Context>* this_handler)
 {
+#if defined(ASIO_NO_DEPRECATED)
+  asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
   return asio_handler_alloc_helpers::allocate(
-      size, this_handler->context_);
+      size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Handler, typename Context>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->context_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Dispatcher, typename Context>
@@ -268,19 +296,27 @@ inline bool asio_handler_is_continuation(
 }
 
 template <typename Function, typename Handler, typename Context>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   asio_handler_invoke_helpers::invoke(
       function, this_handler->context_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Function, typename Handler, typename Context>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   asio_handler_invoke_helpers::invoke(
       function, this_handler->context_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 } // namespace detail

data/ext/third_party/asio/asio/include/asio/dispatch.hpp

@@ -19,6 +19,7 @@
 #include "asio/async_result.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/execution_context.hpp"
+#include "asio/execution/executor.hpp"
 #include "asio/is_executor.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -90,7 +91,9 @@ ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
     const Executor& ex,
     ASIO_MOVE_ARG(CompletionToken) token
       ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    typename enable_if<is_executor<Executor>::value>::type* = 0);
+    typename enable_if<
+      execution::is_executor<Executor>::value || is_executor<Executor>::value
+    >::type* = 0);
 
 /// Submits a completion token or function object for execution.
 /**

data/ext/third_party/asio/asio/include/asio/execution.hpp

@@ -0,0 +1,48 @@
+//
+// execution.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_EXECUTION_HPP
+#define ASIO_EXECUTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/execution/allocator.hpp"
+#include "asio/execution/any_executor.hpp"
+#include "asio/execution/bad_executor.hpp"
+#include "asio/execution/blocking.hpp"
+#include "asio/execution/blocking_adaptation.hpp"
+#include "asio/execution/bulk_execute.hpp"
+#include "asio/execution/bulk_guarantee.hpp"
+#include "asio/execution/connect.hpp"
+#include "asio/execution/context.hpp"
+#include "asio/execution/context_as.hpp"
+#include "asio/execution/execute.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/invocable_archetype.hpp"
+#include "asio/execution/mapping.hpp"
+#include "asio/execution/occupancy.hpp"
+#include "asio/execution/operation_state.hpp"
+#include "asio/execution/outstanding_work.hpp"
+#include "asio/execution/prefer_only.hpp"
+#include "asio/execution/receiver.hpp"
+#include "asio/execution/receiver_invocation_error.hpp"
+#include "asio/execution/relationship.hpp"
+#include "asio/execution/schedule.hpp"
+#include "asio/execution/scheduler.hpp"
+#include "asio/execution/sender.hpp"
+#include "asio/execution/set_done.hpp"
+#include "asio/execution/set_error.hpp"
+#include "asio/execution/set_value.hpp"
+#include "asio/execution/start.hpp"
+#include "asio/execution/submit.hpp"
+
+#endif // ASIO_EXECUTION_HPP