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

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

@@ -97,7 +97,7 @@ public:
     cancel(impl, ec);
   }
 
-  // Move-construct a new serial port implementation.
+  // Move-construct a new timer implementation.
   void move_construct(implementation_type& impl,
       implementation_type& other_impl)
   {
@@ -110,7 +110,7 @@ public:
     other_impl.might_have_pending_waits = false;
   }
 
-  // Move-assign from another serial port implementation.
+  // Move-assign from another timer implementation.
   void move_assign(implementation_type& impl,
       deadline_timer_service& other_service,
       implementation_type& other_impl)
@@ -129,6 +129,21 @@ public:
     other_impl.might_have_pending_waits = false;
   }
 
+  // Move-construct a new timer implementation.
+  void converting_move_construct(implementation_type& impl,
+      deadline_timer_service&, implementation_type& other_impl)
+  {
+    move_construct(impl, other_impl);
+  }
+
+  // Move-assign from another timer implementation.
+  void converting_move_assign(implementation_type& impl,
+      deadline_timer_service& other_service,
+      implementation_type& other_impl)
+  {
+    move_assign(impl, other_service, other_impl);
+  }
+
   // Cancel any asynchronous wait operations associated with the timer.
   std::size_t cancel(implementation_type& impl, asio::error_code& ec)
   {

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

@@ -50,13 +50,18 @@ enum
 
 typedef unsigned char state_type;
 
-template <typename ReturnType>
-inline ReturnType error_wrapper(ReturnType return_value,
-    asio::error_code& ec)
+inline void get_last_error(
+    asio::error_code& ec, bool is_error_condition)
 {
-  ec = asio::error_code(errno,
-      asio::error::get_system_category());
-  return return_value;
+  if (!is_error_condition)
+  {
+    ec.assign(0, ec.category());
+  }
+  else
+  {
+    ec = asio::error_code(errno,
+        asio::error::get_system_category());
+  }
 }
 
 ASIO_DECL int open(const char* path, int flags,
@@ -76,17 +81,30 @@ typedef iovec buf;
 ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs,
     std::size_t count, bool all_empty, asio::error_code& ec);
 
+ASIO_DECL std::size_t sync_read1(int d, state_type state, void* data,
+    std::size_t size, asio::error_code& ec);
+
 ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count,
     asio::error_code& ec, std::size_t& bytes_transferred);
 
+ASIO_DECL bool non_blocking_read1(int d, void* data, std::size_t size,
+    asio::error_code& ec, std::size_t& bytes_transferred);
+
 ASIO_DECL std::size_t sync_write(int d, state_type state,
     const buf* bufs, std::size_t count, bool all_empty,
     asio::error_code& ec);
 
+ASIO_DECL std::size_t sync_write1(int d, state_type state,
+    const void* data, std::size_t size, asio::error_code& ec);
+
 ASIO_DECL bool non_blocking_write(int d,
     const buf* bufs, std::size_t count,
     asio::error_code& ec, std::size_t& bytes_transferred);
 
+ASIO_DECL bool non_blocking_write1(int d,
+    const void* data, std::size_t size,
+    asio::error_code& ec, std::size_t& bytes_transferred);
+
 ASIO_DECL int ioctl(int d, state_type& state, long cmd,
     ioctl_arg_type* arg, asio::error_code& ec);
 

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

@@ -36,9 +36,11 @@ template <typename MutableBufferSequence>
 class descriptor_read_op_base : public reactor_op
 {
 public:
-  descriptor_read_op_base(int descriptor,
-      const MutableBufferSequence& buffers, func_type complete_func)
-    : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
+  descriptor_read_op_base(const asio::error_code& success_ec,
+      int descriptor, const MutableBufferSequence& buffers,
+      func_type complete_func)
+    : reactor_op(success_ec,
+        &descriptor_read_op_base::do_perform, complete_func),
       descriptor_(descriptor),
       buffers_(buffers)
   {
@@ -48,12 +50,24 @@ public:
   {
     descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
 
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(o->buffers_);
+    typedef buffer_sequence_adapter<asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
 
-    status result = descriptor_ops::non_blocking_read(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
-      ? done : not_done;
+    status result;
+    if (bufs_type::is_single_buffer)
+    {
+      result = descriptor_ops::non_blocking_read1(o->descriptor_,
+          bufs_type::first(o->buffers_).data(),
+          bufs_type::first(o->buffers_).size(),
+          o->ec_, o->bytes_transferred_) ? done : not_done;
+    }
+    else
+    {
+      bufs_type bufs(o->buffers_);
+      result = descriptor_ops::non_blocking_read(o->descriptor_,
+          bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
+        ? done : not_done;
+    }
 
     ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_read",
           o->ec_, o->bytes_transferred_));
@@ -73,14 +87,14 @@ class descriptor_read_op
 public:
   ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
 
-  descriptor_read_op(int descriptor, const MutableBufferSequence& buffers,
+  descriptor_read_op(const asio::error_code& success_ec,
+      int descriptor, const MutableBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
-    : descriptor_read_op_base<MutableBufferSequence>(
+    : descriptor_read_op_base<MutableBufferSequence>(success_ec,
         descriptor, buffers, &descriptor_read_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,
@@ -90,10 +104,14 @@ public:
     // Take ownership of the handler object.
     descriptor_read_op* o(static_cast<descriptor_read_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
@@ -117,7 +135,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

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

@@ -36,9 +36,11 @@ template <typename ConstBufferSequence>
 class descriptor_write_op_base : public reactor_op
 {
 public:
-  descriptor_write_op_base(int descriptor,
-      const ConstBufferSequence& buffers, func_type complete_func)
-    : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
+  descriptor_write_op_base(const asio::error_code& success_ec,
+      int descriptor, const ConstBufferSequence& buffers,
+      func_type complete_func)
+    : reactor_op(success_ec,
+        &descriptor_write_op_base::do_perform, complete_func),
       descriptor_(descriptor),
       buffers_(buffers)
   {
@@ -48,12 +50,24 @@ public:
   {
     descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
 
-    buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs(o->buffers_);
+    typedef buffer_sequence_adapter<asio::const_buffer,
+        ConstBufferSequence> bufs_type;
 
-    status result = descriptor_ops::non_blocking_write(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
-      ? done : not_done;
+    status result;
+    if (bufs_type::is_single_buffer)
+    {
+      result = descriptor_ops::non_blocking_write1(o->descriptor_,
+          bufs_type::first(o->buffers_).data(),
+          bufs_type::first(o->buffers_).size(),
+          o->ec_, o->bytes_transferred_) ? done : not_done;
+    }
+    else
+    {
+      bufs_type bufs(o->buffers_);
+      result = descriptor_ops::non_blocking_write(o->descriptor_,
+          bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
+        ? done : not_done;
+    }
 
     ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_write",
           o->ec_, o->bytes_transferred_));
@@ -73,14 +87,14 @@ class descriptor_write_op
 public:
   ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
 
-  descriptor_write_op(int descriptor, const ConstBufferSequence& buffers,
+  descriptor_write_op(const asio::error_code& success_ec,
+      int descriptor, const ConstBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
-    : descriptor_write_op_base<ConstBufferSequence>(
+    : descriptor_write_op_base<ConstBufferSequence>(success_ec,
         descriptor, buffers, &descriptor_write_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,
@@ -90,10 +104,14 @@ public:
     // Take ownership of the handler object.
     descriptor_write_op* o(static_cast<descriptor_write_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
@@ -117,7 +135,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

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

@@ -17,63 +17,87 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/memory.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
 
-class executor_function_base
+#if defined(ASIO_HAS_MOVE)
+
+// Lightweight, move-only function object wrapper.
+class executor_function
 {
 public:
-  void complete()
+  template <typename F, typename Alloc>
+  explicit executor_function(F f, const Alloc& a)
   {
-    func_(this, true);
+    // Allocate and construct an object to wrap the function.
+    typedef impl<F, Alloc> impl_type;
+    typename impl_type::ptr p = {
+      detail::addressof(a), impl_type::ptr::allocate(a), 0 };
+    impl_ = new (p.v) impl_type(ASIO_MOVE_CAST(F)(f), a);
+    p.v = 0;
   }
 
-  void destroy()
+  executor_function(executor_function&& other) ASIO_NOEXCEPT
+    : impl_(other.impl_)
   {
-    func_(this, false);
+    other.impl_ = 0;
   }
 
-protected:
-  typedef void (*func_type)(executor_function_base*, bool);
-
-  executor_function_base(func_type func)
-    : func_(func)
+  ~executor_function()
   {
+    if (impl_)
+      impl_->complete_(impl_, false);
   }
 
-  // Prevents deletion through this type.
-  ~executor_function_base()
+  void operator()()
   {
+    if (impl_)
+    {
+      impl_base* i = impl_;
+      impl_ = 0;
+      i->complete_(i, true);
+    }
   }
 
 private:
-  func_type func_;
-};
-
-template <typename Function, typename Alloc>
-class executor_function : public executor_function_base
-{
-public:
-  ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(
-      thread_info_base::executor_function_tag, executor_function);
+  // Base class for polymorphic function implementations.
+  struct impl_base
+  {
+    void (*complete_)(impl_base*, bool);
+  };
 
-  template <typename F>
-  executor_function(ASIO_MOVE_ARG(F) f, const Alloc& allocator)
-    : executor_function_base(&executor_function::do_complete),
-      function_(ASIO_MOVE_CAST(F)(f)),
-      allocator_(allocator)
+  // Polymorphic function implementation.
+  template <typename Function, typename Alloc>
+  struct impl : impl_base
   {
-  }
+    ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(
+        thread_info_base::executor_function_tag, impl);
+
+    template <typename F>
+    impl(ASIO_MOVE_ARG(F) f, const Alloc& a)
+      : function_(ASIO_MOVE_CAST(F)(f)),
+        allocator_(a)
+    {
+      complete_ = &executor_function::complete<Function, Alloc>;
+    }
 
-  static void do_complete(executor_function_base* base, bool call)
+    Function function_;
+    Alloc allocator_;
+  };
+
+  // Helper to complete function invocation.
+  template <typename Function, typename Alloc>
+  static void complete(impl_base* base, bool call)
   {
     // Take ownership of the function object.
-    executor_function* o(static_cast<executor_function*>(base));
-    Alloc allocator(o->allocator_);
-    ptr p = { detail::addressof(allocator), o, o };
+    impl<Function, Alloc>* i(static_cast<impl<Function, Alloc>*>(base));
+    Alloc allocator(i->allocator_);
+    typename impl<Function, Alloc>::ptr p = {
+      detail::addressof(allocator), i, i };
 
     // Make a copy of the function so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
@@ -81,7 +105,7 @@ public:
     // associated with the function. Consequently, a local copy of the function
     // is required to ensure that any owning sub-object remains valid until
     // after we have deallocated the memory here.
-    Function function(ASIO_MOVE_CAST(Function)(o->function_));
+    Function function(ASIO_MOVE_CAST(Function)(i->function_));
     p.reset();
 
     // Make the upcall if required.
@@ -91,9 +115,84 @@ public:
     }
   }
 
+  impl_base* impl_;
+};
+
+#else // defined(ASIO_HAS_MOVE)
+
+// Not so lightweight, copyable function object wrapper.
+class executor_function
+{
+public:
+  template <typename F, typename Alloc>
+  explicit executor_function(const F& f, const Alloc&)
+    : impl_(new impl<typename decay<F>::type>(f))
+  {
+  }
+
+  void operator()()
+  {
+    impl_->complete_(impl_.get());
+  }
+
 private:
-  Function function_;
-  Alloc allocator_;
+  // Base class for polymorphic function implementations.
+  struct impl_base
+  {
+    void (*complete_)(impl_base*);
+  };
+
+  // Polymorphic function implementation.
+  template <typename F>
+  struct impl : impl_base
+  {
+    impl(const F& f)
+      : function_(f)
+    {
+      complete_ = &executor_function::complete<F>;
+    }
+
+    F function_;
+  };
+
+  // Helper to complete function invocation.
+  template <typename F>
+  static void complete(impl_base* i)
+  {
+    static_cast<impl<F>*>(i)->function_();
+  }
+
+  shared_ptr<impl_base> impl_;
+};
+
+#endif // defined(ASIO_HAS_MOVE)
+
+// Lightweight, non-owning, copyable function object wrapper.
+class executor_function_view
+{
+public:
+  template <typename F>
+  explicit executor_function_view(F& f) ASIO_NOEXCEPT
+    : complete_(&executor_function_view::complete<F>),
+      function_(&f)
+  {
+  }
+
+  void operator()()
+  {
+    complete_(function_);
+  }
+
+private:
+  // Helper to complete function invocation.
+  template <typename F>
+  static void complete(void* f)
+  {
+    (*static_cast<F*>(f))();
+  }
+
+  void (*complete_)(void*);
+  void* function_;
 };
 
 } // namespace detail