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

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

@@ -19,7 +19,6 @@
 #include "asio/detail/bind_handler.hpp"
 #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/signal_op.hpp"
@@ -38,9 +37,8 @@ public:
   signal_handler(Handler& h, const IoExecutor& io_ex)
     : signal_op(&signal_handler::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(h)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -50,10 +48,14 @@ public:
     // Take ownership of the handler object.
     signal_handler* h(static_cast<signal_handler*>(base));
     ptr p = { asio::detail::addressof(h->handler_), h, h };
-    handler_work<Handler, IoExecutor> w(h->handler_, h->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*h));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          h->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
@@ -77,7 +79,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

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

@@ -139,9 +139,15 @@ ASIO_DECL void init_buf(buf& b, const void* data, size_t size);
 ASIO_DECL signed_size_type recv(socket_type s, buf* bufs,
     size_t count, int flags, asio::error_code& ec);
 
+ASIO_DECL signed_size_type recv1(socket_type s,
+    void* data, size_t size, int flags, asio::error_code& ec);
+
 ASIO_DECL size_t sync_recv(socket_type s, state_type state, buf* bufs,
     size_t count, int flags, bool all_empty, asio::error_code& ec);
 
+ASIO_DECL size_t sync_recv1(socket_type s, state_type state,
+    void* data, size_t size, int flags, asio::error_code& ec);
+
 #if defined(ASIO_HAS_IOCP)
 
 ASIO_DECL void complete_iocp_recv(state_type state,
@@ -154,16 +160,28 @@ ASIO_DECL bool non_blocking_recv(socket_type s,
     buf* bufs, size_t count, int flags, bool is_stream,
     asio::error_code& ec, size_t& bytes_transferred);
 
+ASIO_DECL bool non_blocking_recv1(socket_type s,
+    void* data, size_t size, int flags, bool is_stream,
+    asio::error_code& ec, size_t& bytes_transferred);
+
 #endif // defined(ASIO_HAS_IOCP)
 
 ASIO_DECL signed_size_type recvfrom(socket_type s, buf* bufs,
     size_t count, int flags, socket_addr_type* addr,
     std::size_t* addrlen, asio::error_code& ec);
 
+ASIO_DECL signed_size_type recvfrom1(socket_type s, void* data,
+    size_t size, int flags, socket_addr_type* addr,
+    std::size_t* addrlen, asio::error_code& ec);
+
 ASIO_DECL size_t sync_recvfrom(socket_type s, state_type state,
     buf* bufs, size_t count, int flags, socket_addr_type* addr,
     std::size_t* addrlen, asio::error_code& ec);
 
+ASIO_DECL size_t sync_recvfrom1(socket_type s, state_type state,
+    void* data, size_t size, int flags, socket_addr_type* addr,
+    std::size_t* addrlen, asio::error_code& ec);
+
 #if defined(ASIO_HAS_IOCP)
 
 ASIO_DECL void complete_iocp_recvfrom(
@@ -177,6 +195,11 @@ ASIO_DECL bool non_blocking_recvfrom(socket_type s,
     socket_addr_type* addr, std::size_t* addrlen,
     asio::error_code& ec, size_t& bytes_transferred);
 
+ASIO_DECL bool non_blocking_recvfrom1(socket_type s,
+    void* data, size_t size, int flags,
+    socket_addr_type* addr, std::size_t* addrlen,
+    asio::error_code& ec, size_t& bytes_transferred);
+
 #endif // defined(ASIO_HAS_IOCP)
 
 ASIO_DECL signed_size_type recvmsg(socket_type s, buf* bufs,
@@ -204,10 +227,16 @@ ASIO_DECL bool non_blocking_recvmsg(socket_type s,
 ASIO_DECL signed_size_type send(socket_type s, const buf* bufs,
     size_t count, int flags, asio::error_code& ec);
 
+ASIO_DECL signed_size_type send1(socket_type s,
+    const void* data, size_t size, int flags, asio::error_code& ec);
+
 ASIO_DECL size_t sync_send(socket_type s, state_type state,
     const buf* bufs, size_t count, int flags,
     bool all_empty, asio::error_code& ec);
 
+ASIO_DECL size_t sync_send1(socket_type s, state_type state,
+    const void* data, size_t size, int flags, asio::error_code& ec);
+
 #if defined(ASIO_HAS_IOCP)
 
 ASIO_DECL void complete_iocp_send(
@@ -220,16 +249,28 @@ ASIO_DECL bool non_blocking_send(socket_type s,
     const buf* bufs, size_t count, int flags,
     asio::error_code& ec, size_t& bytes_transferred);
 
+ASIO_DECL bool non_blocking_send1(socket_type s,
+    const void* data, size_t size, int flags,
+    asio::error_code& ec, size_t& bytes_transferred);
+
 #endif // defined(ASIO_HAS_IOCP)
 
 ASIO_DECL signed_size_type sendto(socket_type s, const buf* bufs,
     size_t count, int flags, const socket_addr_type* addr,
     std::size_t addrlen, asio::error_code& ec);
 
+ASIO_DECL signed_size_type sendto1(socket_type s, const void* data,
+    size_t size, int flags, const socket_addr_type* addr,
+    std::size_t addrlen, asio::error_code& ec);
+
 ASIO_DECL size_t sync_sendto(socket_type s, state_type state,
     const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
     std::size_t addrlen, asio::error_code& ec);
 
+ASIO_DECL size_t sync_sendto1(socket_type s, state_type state,
+    const void* data, size_t size, int flags, const socket_addr_type* addr,
+    std::size_t addrlen, asio::error_code& ec);
+
 #if !defined(ASIO_HAS_IOCP)
 
 ASIO_DECL bool non_blocking_sendto(socket_type s,
@@ -237,6 +278,11 @@ ASIO_DECL bool non_blocking_sendto(socket_type s,
     const socket_addr_type* addr, std::size_t addrlen,
     asio::error_code& ec, size_t& bytes_transferred);
 
+ASIO_DECL bool non_blocking_sendto1(socket_type s,
+    const void* data, size_t size, int flags,
+    const socket_addr_type* addr, std::size_t addrlen,
+    asio::error_code& ec, size_t& bytes_transferred);
+
 #endif // !defined(ASIO_HAS_IOCP)
 
 ASIO_DECL socket_type socket(int af, int type, int protocol,

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

@@ -0,0 +1,45 @@
+//
+// detail/source_location.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_DETAIL_SOURCE_LOCATION_HPP
+#define ASIO_DETAIL_SOURCE_LOCATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_SOURCE_LOCATION)
+
+#if defined(ASIO_HAS_STD_SOURCE_LOCATION)
+# include <source_location>
+#elif defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
+# include <experimental/source_location>
+#else // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
+# error ASIO_HAS_SOURCE_LOCATION is set \
+  but no source_location is available
+#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
+
+namespace asio {
+namespace detail {
+
+#if defined(ASIO_HAS_STD_SOURCE_LOCATION)
+using std::source_location;
+#elif defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
+using std::experimental::source_location;
+#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
+
+} // namespace detail
+} // namespace asio
+
+#endif // defined(ASIO_HAS_SOURCE_LOCATION)
+
+#endif // ASIO_DETAIL_SOURCE_LOCATION_HPP

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

@@ -73,6 +73,18 @@ public:
       cond_.notify_one();
   }
 
+  // Unlock the mutex and signal one waiter who may destroy us.
+  template <typename Lock>
+  void unlock_and_signal_one(Lock& lock)
+  {
+    ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    bool have_waiters = (state_ > 1);
+    if (have_waiters)
+      cond_.notify_one();
+    lock.unlock();
+  }
+
   // If there's a waiter, unlock the mutex and signal it.
   template <typename Lock>
   bool maybe_unlock_and_signal_one(Lock& lock)

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

@@ -23,6 +23,8 @@
 #include "asio/detail/op_queue.hpp"
 #include "asio/detail/scheduler_operation.hpp"
 #include "asio/detail/scoped_ptr.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution.hpp"
 #include "asio/execution_context.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -85,6 +87,22 @@ public:
   // Create a new strand_executor implementation.
   ASIO_DECL implementation_type create_implementation();
 
+  // Request invocation of the given function.
+  template <typename Executor, typename Function>
+  static void execute(const implementation_type& impl, Executor& ex,
+      ASIO_MOVE_ARG(Function) function,
+      typename enable_if<
+        can_query<Executor, execution::allocator_t<void> >::value
+      >::type* = 0);
+
+  // Request invocation of the given function.
+  template <typename Executor, typename Function>
+  static void execute(const implementation_type& impl, Executor& ex,
+      ASIO_MOVE_ARG(Function) function,
+      typename enable_if<
+        !can_query<Executor, execution::allocator_t<void> >::value
+      >::type* = 0);
+
   // Request invocation of the given function.
   template <typename Executor, typename Function, typename Allocator>
   static void dispatch(const implementation_type& impl, Executor& ex,
@@ -106,12 +124,18 @@ public:
 
 private:
   friend class strand_impl;
-  template <typename Executor> class invoker;
+  template <typename F, typename Allocator> class allocator_binder;
+  template <typename Executor, typename = void> class invoker;
 
   // Adds a function to the strand. Returns true if it acquires the lock.
   ASIO_DECL static bool enqueue(const implementation_type& impl,
       scheduler_operation* op);
 
+  // Helper function to request invocation of the given function.
+  template <typename Executor, typename Function, typename Allocator>
+  static void do_execute(const implementation_type& impl, Executor& ex,
+      ASIO_MOVE_ARG(Function) function, const Allocator& a);
+
   // Mutex to protect access to the service-wide state.
   mutex mutex_;
 

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

@@ -108,8 +108,11 @@ private:
       operation* base, const asio::error_code& ec,
       std::size_t bytes_transferred);
 
+  // The io_context used to obtain an I/O executor.
+  io_context& io_context_;
+
   // The io_context implementation used to post completions.
-  io_context_impl& io_context_;
+  io_context_impl& io_context_impl_;
 
   // Mutex to protect access to the array of implementations.
   asio::detail::mutex mutex_;

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

@@ -15,10 +15,18 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include "asio/detail/config.hpp"
 #include <climits>
 #include <cstddef>
 #include "asio/detail/noncopyable.hpp"
 
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+# include <exception>
+# include "asio/multiple_exceptions.hpp"
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       // && !defined(ASIO_NO_EXCEPTIONS)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
@@ -44,6 +52,11 @@ public:
   };
 
   thread_info_base()
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+    : has_pending_exception_(0)
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       // && !defined(ASIO_NO_EXCEPTIONS)
   {
     for (int i = 0; i < max_mem_index; ++i)
       reusable_memory_[i] = 0;
@@ -111,10 +124,55 @@ public:
     ::operator delete(pointer);
   }
 
+  void capture_current_exception()
+  {
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+    switch (has_pending_exception_)
+    {
+    case 0:
+      has_pending_exception_ = 1;
+      pending_exception_ = std::current_exception();
+      break;
+    case 1:
+      has_pending_exception_ = 2;
+      pending_exception_ =
+        std::make_exception_ptr<multiple_exceptions>(
+            multiple_exceptions(pending_exception_));
+    default:
+      break;
+    }
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       // && !defined(ASIO_NO_EXCEPTIONS)
+  }
+
+  void rethrow_pending_exception()
+  {
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+    if (has_pending_exception_ > 0)
+    {
+      has_pending_exception_ = 0;
+      std::exception_ptr ex(
+          ASIO_MOVE_CAST(std::exception_ptr)(
+            pending_exception_));
+      std::rethrow_exception(ex);
+    }
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       // && !defined(ASIO_NO_EXCEPTIONS)
+  }
+
 private:
   enum { chunk_size = 4 };
   enum { max_mem_index = 3 };
   void* reusable_memory_[max_mem_index];
+
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  && !defined(ASIO_NO_EXCEPTIONS)
+  int has_pending_exception_;
+  std::exception_ptr pending_exception_;
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       // && !defined(ASIO_NO_EXCEPTIONS)
 };
 
 } // namespace detail

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

@@ -21,15 +21,25 @@
 # include <type_traits>
 #else // defined(ASIO_HAS_STD_TYPE_TRAITS)
 # include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/add_lvalue_reference.hpp>
+# include <boost/type_traits/aligned_storage.hpp>
+# include <boost/type_traits/alignment_of.hpp>
 # include <boost/type_traits/conditional.hpp>
 # include <boost/type_traits/decay.hpp>
+# include <boost/type_traits/has_nothrow_copy.hpp>
+# include <boost/type_traits/has_nothrow_destructor.hpp>
 # include <boost/type_traits/integral_constant.hpp>
 # include <boost/type_traits/is_base_of.hpp>
 # include <boost/type_traits/is_class.hpp>
 # include <boost/type_traits/is_const.hpp>
 # include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_constructible.hpp>
+# include <boost/type_traits/is_copy_constructible.hpp>
+# include <boost/type_traits/is_destructible.hpp>
 # include <boost/type_traits/is_function.hpp>
+# include <boost/type_traits/is_object.hpp>
 # include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/remove_cv.hpp>
 # include <boost/type_traits/remove_pointer.hpp>
 # include <boost/type_traits/remove_reference.hpp>
 # include <boost/utility/declval.hpp>
@@ -41,6 +51,9 @@ namespace asio {
 
 #if defined(ASIO_HAS_STD_TYPE_TRAITS)
 using std::add_const;
+using std::add_lvalue_reference;
+using std::aligned_storage;
+using std::alignment_of;
 using std::conditional;
 using std::decay;
 using std::declval;
@@ -50,9 +63,21 @@ using std::integral_constant;
 using std::is_base_of;
 using std::is_class;
 using std::is_const;
+using std::is_constructible;
 using std::is_convertible;
+using std::is_copy_constructible;
+using std::is_destructible;
 using std::is_function;
+using std::is_move_constructible;
+using std::is_nothrow_copy_constructible;
+using std::is_nothrow_destructible;
+using std::is_object;
+using std::is_reference;
 using std::is_same;
+using std::is_scalar;
+using std::remove_cv;
+template <typename T>
+struct remove_cvref : remove_cv<typename std::remove_reference<T>::type> {};
 using std::remove_pointer;
 using std::remove_reference;
 #if defined(ASIO_HAS_STD_INVOKE_RESULT)
@@ -65,6 +90,9 @@ using std::result_of;
 using std::true_type;
 #else // defined(ASIO_HAS_STD_TYPE_TRAITS)
 using boost::add_const;
+using boost::add_lvalue_reference;
+using boost::aligned_storage;
+using boost::alignment_of;
 template <bool Condition, typename Type = void>
 struct enable_if : boost::enable_if_c<Condition, Type> {};
 using boost::conditional;
@@ -75,15 +103,46 @@ using boost::integral_constant;
 using boost::is_base_of;
 using boost::is_class;
 using boost::is_const;
+using boost::is_constructible;
 using boost::is_convertible;
+using boost::is_copy_constructible;
+using boost::is_destructible;
 using boost::is_function;
+#if defined(ASIO_HAS_MOVE)
+template <typename T>
+struct is_move_constructible : false_type {};
+#else // defined(ASIO_HAS_MOVE)
+template <typename T>
+struct is_move_constructible : is_copy_constructible<T> {};
+#endif // defined(ASIO_HAS_MOVE)
+template <typename T>
+struct is_nothrow_copy_constructible : boost::has_nothrow_copy<T> {};
+template <typename T>
+struct is_nothrow_destructible : boost::has_nothrow_destructor<T> {};
+using boost::is_object;
+using boost::is_reference;
 using boost::is_same;
+using boost::is_scalar;
+using boost::remove_cv;
+template <typename T>
+struct remove_cvref : remove_cv<typename boost::remove_reference<T>::type> {};
 using boost::remove_pointer;
 using boost::remove_reference;
 using boost::result_of;
 using boost::true_type;
 #endif // defined(ASIO_HAS_STD_TYPE_TRAITS)
 
+template <typename> struct void_type { typedef void type; };
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename...> struct conjunction : true_type {};
+template <typename T> struct conjunction<T> : T {};
+template <typename Head, typename... Tail> struct conjunction<Head, Tail...> :
+  conditional<Head::value, conjunction<Tail...>, Head>::type {};
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
 } // namespace asio
 
 #endif // ASIO_DETAIL_TYPE_TRAITS_HPP