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

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

@@ -16,8 +16,10 @@
 #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/executor_function.hpp"
 #include "asio/detail/global.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/recycling_allocator.hpp"
@@ -30,99 +32,7 @@ namespace asio {
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-#if defined(ASIO_HAS_MOVE)
-
-// Lightweight, move-only function object wrapper.
-class executor::function
-{
-public:
-  template <typename F, typename Alloc>
-  explicit function(F f, const Alloc& a)
-  {
-    // Allocate and construct an operation to wrap the function.
-    typedef detail::executor_function<F, Alloc> func_type;
-    typename func_type::ptr p = {
-      detail::addressof(a), func_type::ptr::allocate(a), 0 };
-    func_ = new (p.v) func_type(ASIO_MOVE_CAST(F)(f), a);
-    p.v = 0;
-  }
-
-  function(function&& other) ASIO_NOEXCEPT
-    : func_(other.func_)
-  {
-    other.func_ = 0;
-  }
-
-  ~function()
-  {
-    if (func_)
-      func_->destroy();
-  }
-
-  void operator()()
-  {
-    if (func_)
-    {
-      detail::executor_function_base* func = func_;
-      func_ = 0;
-      func->complete();
-    }
-  }
-
-private:
-  detail::executor_function_base* func_;
-};
-
-#else // defined(ASIO_HAS_MOVE)
-
-// Not so lightweight, copyable function object wrapper.
-class executor::function
-{
-public:
-  template <typename F, typename Alloc>
-  explicit function(const F& f, const Alloc&)
-    : impl_(new impl<F>(f))
-  {
-  }
-
-  void operator()()
-  {
-    impl_->invoke_(impl_.get());
-  }
-
-private:
-  // Base class for polymorphic function implementations.
-  struct impl_base
-  {
-    void (*invoke_)(impl_base*);
-  };
-
-  // Polymorphic function implementation.
-  template <typename F>
-  struct impl : impl_base
-  {
-    impl(const F& f)
-      : function_(f)
-    {
-      invoke_ = &function::invoke<F>;
-    }
-
-    F function_;
-  };
-
-  // Helper to invoke a function.
-  template <typename F>
-  static void invoke(impl_base* i)
-  {
-    static_cast<impl<F>*>(i)->function_();
-  }
-
-  detail::shared_ptr<impl_base> impl_;
-};
-
-#endif // defined(ASIO_HAS_MOVE)
-
-// Default polymorphic allocator implementation.
+// Default polymorphic executor implementation.
 template <typename Executor, typename Allocator>
 class executor::impl
   : public executor::impl_base
@@ -148,13 +58,13 @@ public:
 
   impl_base* clone() const ASIO_NOEXCEPT
   {
-    ++ref_count_;
+    detail::ref_count_up(ref_count_);
     return const_cast<impl_base*>(static_cast<const impl_base*>(this));
   }
 
   void destroy() ASIO_NOEXCEPT
   {
-    if (--ref_count_ == 0)
+    if (detail::ref_count_down(ref_count_))
     {
       allocator_type alloc(allocator_);
       impl* p = this;
@@ -246,7 +156,7 @@ private:
   };
 };
 
-// Polymorphic allocator specialisation for system_executor.
+// Polymorphic executor specialisation for system_executor.
 template <typename Allocator>
 class executor::impl<system_executor, Allocator>
   : public executor::impl_base
@@ -289,17 +199,20 @@ public:
 
   void dispatch(ASIO_MOVE_ARG(function) f)
   {
-    executor_.dispatch(ASIO_MOVE_CAST(function)(f), allocator_);
+    executor_.dispatch(ASIO_MOVE_CAST(function)(f),
+        std::allocator<void>());
   }
 
   void post(ASIO_MOVE_ARG(function) f)
   {
-    executor_.post(ASIO_MOVE_CAST(function)(f), allocator_);
+    executor_.post(ASIO_MOVE_CAST(function)(f),
+        std::allocator<void>());
   }
 
   void defer(ASIO_MOVE_ARG(function) f)
   {
-    executor_.defer(ASIO_MOVE_CAST(function)(f), allocator_);
+    executor_.defer(ASIO_MOVE_CAST(function)(f),
+        std::allocator<void>());
   }
 
   type_id_result_type target_type() const ASIO_NOEXCEPT
@@ -324,7 +237,6 @@ public:
 
 private:
   system_executor executor_;
-  Allocator allocator_;
 };
 
 template <typename Executor>
@@ -384,4 +296,6 @@ const Executor* executor::target() const ASIO_NOEXCEPT
 
 #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

@@ -16,6 +16,9 @@
 #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"
@@ -35,4 +38,6 @@ const char* bad_executor::what() const ASIO_NOEXCEPT_OR_NOTHROW
 
 #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

@@ -24,9 +24,13 @@
 
 namespace asio {
 
-void* asio_handler_allocate(std::size_t size, ...)
+asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size, ...)
 {
-#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+#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)
@@ -34,9 +38,14 @@ void* asio_handler_allocate(std::size_t size, ...)
 #endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 }
 
-void asio_handler_deallocate(void* pointer, std::size_t size, ...)
+asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size, ...)
 {
-#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+#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)

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

@@ -27,10 +27,10 @@
 
 #include "asio/detail/push_options.hpp"
 
-#if !defined(GENERATING_DOCUMENTATION)
-
 namespace asio {
 
+#if !defined(GENERATING_DOCUMENTATION)
+
 template <typename Service>
 inline Service& use_service(io_context& ioc)
 {
@@ -48,22 +48,8 @@ inline detail::io_context_impl& use_service<detail::io_context_impl>(
   return ioc.impl_;
 }
 
-} // namespace asio
-
 #endif // !defined(GENERATING_DOCUMENTATION)
 
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else
-# include "asio/detail/scheduler.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
 inline io_context::executor_type
 io_context::get_executor() ASIO_NOEXCEPT
 {
@@ -154,10 +140,10 @@ struct io_context::initiate_dispatch
     {
       // Allocate and construct an operation to wrap the handler.
       typedef detail::completion_handler<
-        typename decay<LegacyCompletionHandler>::type> op;
+        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);
+      p.p = new (p.v) op(handler2.value, self->get_executor());
 
       ASIO_HANDLER_CREATION((*self, *p.p,
             "io_context", self, 0, "dispatch"));
@@ -194,10 +180,10 @@ struct io_context::initiate_post
 
     // Allocate and construct an operation to wrap the handler.
     typedef detail::completion_handler<
-      typename decay<LegacyCompletionHandler>::type> op;
+      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);
+    p.p = new (p.v) op(handler2.value, self->get_executor());
 
     ASIO_HANDLER_CREATION((*self, *p.p,
           "io_context", self, 0, "post"));
@@ -228,32 +214,133 @@ io_context::wrap(Handler handler)
 
 #endif // !defined(ASIO_NO_DEPRECATED)
 
-inline io_context&
-io_context::executor_type::context() const ASIO_NOEXCEPT
+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
 {
-  return io_context_;
+  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;
 }
 
-inline void
-io_context::executor_type::on_work_started() const ASIO_NOEXCEPT
+#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
 {
-  io_context_.impl_.work_started();
+  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)
 
-inline void
-io_context::executor_type::on_work_finished() const ASIO_NOEXCEPT
+template <typename Allocator, unsigned int Bits>
+inline bool io_context::basic_executor_type<Allocator,
+    Bits>::running_in_this_thread() const ASIO_NOEXCEPT
 {
-  io_context_.impl_.work_finished();
+  return io_context_->impl_.can_dispatch();
 }
 
-template <typename Function, typename Allocator>
-void io_context::executor_type::dispatch(
-    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+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())
+  if (io_context_->impl_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
     function_type tmp(ASIO_MOVE_CAST(Function)(f));
@@ -264,58 +351,58 @@ void io_context::executor_type::dispatch(
   }
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
+  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((this->context(), *p.p,
-        "io_context", &this->context(), 0, "dispatch"));
+  ASIO_HANDLER_CREATION((*io_context_, *p.p,
+        "io_context", io_context_, 0, "dispatch"));
 
-  io_context_.impl_.post_immediate_completion(p.p, false);
+  io_context_->impl_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void io_context::executor_type::post(
-    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+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, Allocator, detail::operation> op;
+  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((this->context(), *p.p,
-        "io_context", &this->context(), 0, "post"));
+  ASIO_HANDLER_CREATION((*io_context_, *p.p,
+        "io_context", io_context_, 0, "post"));
 
-  io_context_.impl_.post_immediate_completion(p.p, false);
+  io_context_->impl_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Function, typename Allocator>
-void io_context::executor_type::defer(
-    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
+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, Allocator, detail::operation> op;
+  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((this->context(), *p.p,
-        "io_context", &this->context(), 0, "defer"));
+  ASIO_HANDLER_CREATION((*io_context_, *p.p,
+        "io_context", io_context_, 0, "defer"));
 
-  io_context_.impl_.post_immediate_completion(p.p, true);
+  io_context_->impl_.post_immediate_completion(p.p, true);
   p.v = p.p = 0;
 }
-
-inline bool
-io_context::executor_type::running_in_this_thread() const ASIO_NOEXCEPT
-{
-  return io_context_.impl_.can_dispatch();
-}
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
 
 #if !defined(ASIO_NO_DEPRECATED)
 inline io_context::work::work(asio::io_context& io_context)