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

data/ext/third_party/asio/asio/include/asio/impl/redirect_error.hpp

@@ -125,19 +125,29 @@ public:
 };
 
 template <typename Handler>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     redirect_error_handler<Handler>* 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 Handler>
-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,
     redirect_error_handler<Handler>* 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 Handler>
@@ -149,19 +159,27 @@ inline bool asio_handler_is_continuation(
 }
 
 template <typename Function, typename Handler>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     redirect_error_handler<Handler>* this_handler)
 {
   asio_handler_invoke_helpers::invoke(
       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 Handler>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     redirect_error_handler<Handler>* this_handler)
 {
   asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 template <typename Signature>

data/ext/third_party/asio/asio/include/asio/impl/spawn.hpp

@@ -109,19 +109,29 @@ namespace detail {
   };
 
   template <typename Handler, typename T>
-  inline void* asio_handler_allocate(std::size_t size,
+  inline asio_handler_allocate_is_deprecated
+  asio_handler_allocate(std::size_t size,
       coro_handler<Handler, T>* 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 Handler, typename T>
-  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,
       coro_handler<Handler, T>* 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 Handler, typename T>
@@ -131,19 +141,27 @@ namespace detail {
   }
 
   template <typename Function, typename Handler, typename T>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       coro_handler<Handler, T>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         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 Handler, typename T>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       coro_handler<Handler, T>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         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 T>
@@ -344,6 +362,20 @@ namespace detail {
   template <typename Handler, typename Function>
   struct spawn_helper
   {
+    typedef typename associated_allocator<Handler>::type allocator_type;
+
+    allocator_type get_allocator() const ASIO_NOEXCEPT
+    {
+      return (get_associated_allocator)(data_->handler_);
+    }
+
+    typedef typename associated_executor<Handler>::type executor_type;
+
+    executor_type get_executor() const ASIO_NOEXCEPT
+    {
+      return (get_associated_executor)(data_->handler_);
+    }
+
     void operator()()
     {
       typedef typename basic_yield_context<Handler>::callee_type callee_type;
@@ -358,19 +390,27 @@ namespace detail {
   };
 
   template <typename Function, typename Handler, typename Function1>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       spawn_helper<Handler, Function1>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->data_->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Function, typename Handler, typename Function1>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       spawn_helper<Handler, Function1>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->data_->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   inline void default_spawn_handler() {}
@@ -393,18 +433,14 @@ template <typename Handler, typename Function>
 void spawn(ASIO_MOVE_ARG(Handler) handler,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes,
-    typename enable_if<!is_executor<typename decay<Handler>::type>::value &&
+    typename enable_if<
+      !is_executor<typename decay<Handler>::type>::value &&
+      !execution::is_executor<typename decay<Handler>::type>::value &&
       !is_convertible<Handler&, execution_context&>::value>::type*)
 {
   typedef typename decay<Handler>::type handler_type;
   typedef typename decay<Function>::type function_type;
 
-  typename associated_executor<handler_type>::type ex(
-      (get_associated_executor)(handler));
-
-  typename associated_allocator<handler_type>::type a(
-      (get_associated_allocator)(handler));
-
   detail::spawn_helper<handler_type, function_type> helper;
   helper.data_.reset(
       new detail::spawn_data<handler_type, function_type>(
@@ -412,7 +448,7 @@ void spawn(ASIO_MOVE_ARG(Handler) handler,
         ASIO_MOVE_CAST(Function)(function)));
   helper.attributes_ = attributes;
 
-  ex.dispatch(helper, a);
+  asio::dispatch(helper);
 }
 
 template <typename Handler, typename Function>
@@ -424,12 +460,6 @@ void spawn(basic_yield_context<Handler> ctx,
 
   Handler handler(ctx.handler_); // Explicit copy that might be moved from.
 
-  typename associated_executor<Handler>::type ex(
-      (get_associated_executor)(handler));
-
-  typename associated_allocator<Handler>::type a(
-      (get_associated_allocator)(handler));
-
   detail::spawn_helper<Handler, function_type> helper;
   helper.data_.reset(
       new detail::spawn_data<Handler, function_type>(
@@ -437,14 +467,16 @@ void spawn(basic_yield_context<Handler> ctx,
         ASIO_MOVE_CAST(Function)(function)));
   helper.attributes_ = attributes;
 
-  ex.dispatch(helper, a);
+  asio::dispatch(helper);
 }
 
 template <typename Function, typename Executor>
 inline void spawn(const Executor& ex,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes,
-    typename enable_if<is_executor<Executor>::value>::type*)
+    typename enable_if<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type*)
 {
   asio::spawn(asio::strand<Executor>(ex),
       ASIO_MOVE_CAST(Function)(function), attributes);
@@ -460,6 +492,8 @@ inline void spawn(const strand<Executor>& ex,
       ASIO_MOVE_CAST(Function)(function), attributes);
 }
 
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
 template <typename Function>
 inline void spawn(const asio::io_context::strand& s,
     ASIO_MOVE_ARG(Function) function,
@@ -470,6 +504,8 @@ inline void spawn(const asio::io_context::strand& s,
       ASIO_MOVE_CAST(Function)(function), attributes);
 }
 
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
 template <typename Function, typename ExecutionContext>
 inline void spawn(ExecutionContext& ctx,
     ASIO_MOVE_ARG(Function) function,

data/ext/third_party/asio/asio/include/asio/impl/src.hpp

@@ -25,6 +25,7 @@
 #include "asio/impl/executor.ipp"
 #include "asio/impl/handler_alloc_hook.ipp"
 #include "asio/impl/io_context.ipp"
+#include "asio/impl/multiple_exceptions.ipp"
 #include "asio/impl/serial_port_base.ipp"
 #include "asio/impl/system_context.ipp"
 #include "asio/impl/thread_pool.ipp"
@@ -69,6 +70,8 @@
 #include "asio/detail/impl/winrt_ssocket_service_base.ipp"
 #include "asio/detail/impl/winrt_timer_scheduler.ipp"
 #include "asio/detail/impl/winsock_init.ipp"
+#include "asio/execution/impl/bad_executor.ipp"
+#include "asio/execution/impl/receiver_invocation_error.ipp"
 #include "asio/generic/detail/impl/endpoint.ipp"
 #include "asio/ip/impl/address.ipp"
 #include "asio/ip/impl/address_v4.ipp"

data/ext/third_party/asio/asio/include/asio/impl/system_context.ipp

@@ -28,8 +28,19 @@ struct system_context::thread_function
 
   void operator()()
   {
-    asio::error_code ec;
-    scheduler_->run(ec);
+#if !defined(ASIO_NO_EXCEPTIONS)
+    try
+    {
+#endif// !defined(ASIO_NO_EXCEPTIONS)
+      asio::error_code ec;
+      scheduler_->run(ec);
+#if !defined(ASIO_NO_EXCEPTIONS)
+    }
+    catch (...)
+    {
+      std::terminate();
+    }
+#endif// !defined(ASIO_NO_EXCEPTIONS)
   }
 };
 
@@ -39,8 +50,9 @@ system_context::system_context()
   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()

data/ext/third_party/asio/asio/include/asio/impl/system_executor.hpp

@@ -25,29 +25,128 @@
 
 namespace asio {
 
-inline system_context& system_executor::context() const ASIO_NOEXCEPT
+template <typename Blocking, typename Relationship, typename Allocator>
+inline system_context&
+basic_system_executor<Blocking, Relationship, Allocator>::query(
+    execution::context_t) ASIO_NOEXCEPT
 {
   return detail::global<system_context>();
 }
 
-template <typename Function, typename Allocator>
-void system_executor::dispatch(
-    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 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(
+    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(ASIO_NO_EXCEPTIONS)
+  try
+  {
+#endif// !defined(ASIO_NO_EXCEPTIONS)
+    detail::fenced_block b(detail::fenced_block::full);
+    asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+#if !defined(ASIO_NO_EXCEPTIONS)
+  }
+  catch (...)
+  {
+    std::terminate();
+  }
+#endif// !defined(ASIO_NO_EXCEPTIONS)
+}
+
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function>
+inline void
+basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
+    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(ASIO_NO_EXCEPTIONS)
+  try
+  {
+#endif// !defined(ASIO_NO_EXCEPTIONS)
+    detail::fenced_block b(detail::fenced_block::full);
+    asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+#if !defined(ASIO_NO_EXCEPTIONS)
+  }
+  catch (...)
+  {
+    std::terminate();
+  }
+#endif// !defined(ASIO_NO_EXCEPTIONS)
+}
+
+template <typename Blocking, typename Relationship, typename Allocator>
+template <typename Function>
+void basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
+    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(ASIO_MOVE_CAST(Function)(f), allocator_);
+
+  if (is_same<Relationship, execution::relationship_t::continuation_t>::value)
+  {
+    ASIO_HANDLER_CREATION((ctx, *p.p,
+          "system_executor", &ctx, 0, "execute(blk=never,rel=cont)"));
+  }
+  else
+  {
+    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(ASIO_NO_TS_EXECUTORS)
+template <typename Blocking, typename Relationship, typename Allocator>
+inline system_context& basic_system_executor<
+    Blocking, Relationship, Allocator>::context() const 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(
+    ASIO_MOVE_ARG(Function) f, const OtherAllocator&) const
 {
   typename decay<Function>::type tmp(ASIO_MOVE_CAST(Function)(f));
   asio_handler_invoke_helpers::invoke(tmp, tmp);
 }
 
-template <typename Function, typename Allocator>
-void system_executor::post(
-    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(
+    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(ASIO_MOVE_CAST(Function)(f), a);
 
@@ -58,16 +157,17 @@ void system_executor::post(
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void system_executor::defer(
-    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(
+    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(ASIO_MOVE_CAST(Function)(f), a);
 
@@ -77,6 +177,7 @@ void system_executor::defer(
   ctx.scheduler_.post_immediate_completion(p.p, true);
   p.v = p.p = 0;
 }
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
 
 } // namespace asio