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

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

@@ -0,0 +1,310 @@
+//
+// require_concept.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_REQUIRE_CONCEPT_HPP
+#define ASIO_REQUIRE_CONCEPT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/is_applicable_property.hpp"
+#include "asio/traits/require_concept_member.hpp"
+#include "asio/traits/require_concept_free.hpp"
+#include "asio/traits/static_require_concept.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace asio {
+
+/// A customisation point that applies a concept-enforcing property to an
+/// object.
+/**
+ * The name <tt>require_concept</tt> denotes a customization point object. The
+ * expression <tt>asio::require_concept(E, P)</tt> for some
+ * subexpressions <tt>E</tt> and <tt>P</tt> (with types <tt>T =
+ * decay_t<decltype(E)></tt> and <tt>Prop = decay_t<decltype(P)></tt>) is
+ * expression-equivalent to:
+ *
+ * @li If <tt>is_applicable_property_v<T, Prop> &&
+ *   Prop::is_requirable_concept</tt> is not a well-formed constant expression
+ *   with value <tt>true</tt>, <tt>asio::require_concept(E, P)</tt> is
+ *   ill-formed.
+ *
+ * @li Otherwise, <tt>E</tt> if the expression <tt>Prop::template
+ *   static_query_v<T> == Prop::value()</tt> is a well-formed constant
+ *   expression with value <tt>true</tt>.
+ *
+ * @li Otherwise, <tt>(E).require_concept(P)</tt> if the expression
+ *   <tt>(E).require_concept(P)</tt> is well-formed.
+ *
+ * @li Otherwise, <tt>require_concept(E, P)</tt> if the expression
+ *   <tt>require_concept(E, P)</tt> is a valid expression with overload
+ *   resolution performed in a context that does not include the declaration
+ *   of the <tt>require_concept</tt> customization point object.
+ *
+ * @li Otherwise, <tt>asio::require_concept(E, P)</tt> is ill-formed.
+ */
+inline constexpr unspecified require_concept = unspecified;
+
+/// A type trait that determines whether a @c require_concept expression is
+/// well-formed.
+/**
+ * Class template @c can_require_concept is a trait that is derived from
+ * @c true_type if the expression
+ * <tt>asio::require_concept(std::declval<T>(),
+ * std::declval<Property>())</tt> is well formed; otherwise @c false_type.
+ */
+template <typename T, typename Property>
+struct can_require_concept :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines whether a @c require_concept expression will
+/// not throw.
+/**
+ * Class template @c is_nothrow_require_concept is a trait that is derived from
+ * @c true_type if the expression
+ * <tt>asio::require_concept(std::declval<T>(),
+ * std::declval<Property>())</tt> is @c noexcept; otherwise @c false_type.
+ */
+template <typename T, typename Property>
+struct is_nothrow_require_concept :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines the result type of a @c require_concept
+/// expression.
+/**
+ * Class template @c require_concept_result is a trait that determines the
+ * result type of the expression
+ * <tt>asio::require_concept(std::declval<T>(),
+ * std::declval<Property>())</tt>.
+ */
+template <typename T, typename Property>
+struct require_concept_result
+{
+  /// The result of the @c require_concept expression.
+  typedef automatically_determined type;
+};
+
+} // namespace asio
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace asio_require_concept_fn {
+
+using asio::decay;
+using asio::declval;
+using asio::enable_if;
+using asio::is_applicable_property;
+using asio::traits::require_concept_free;
+using asio::traits::require_concept_member;
+using asio::traits::static_require_concept;
+
+void require_concept();
+
+enum overload_type
+{
+  identity,
+  call_member,
+  call_free,
+  ill_formed
+};
+
+template <typename T, typename Properties, typename = void>
+struct call_traits
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false);
+  typedef void result_type;
+};
+
+template <typename T, typename Property>
+struct call_traits<T, void(Property),
+  typename enable_if<
+    (
+      is_applicable_property<
+        typename decay<T>::type,
+        typename decay<Property>::type
+      >::value
+      &&
+      decay<Property>::type::is_requirable_concept
+      &&
+      static_require_concept<T, Property>::is_valid
+    )
+  >::type>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
+  typedef ASIO_MOVE_ARG(T) result_type;
+};
+
+template <typename T, typename Property>
+struct call_traits<T, void(Property),
+  typename enable_if<
+    (
+      is_applicable_property<
+        typename decay<T>::type,
+        typename decay<Property>::type
+      >::value
+      &&
+      decay<Property>::type::is_requirable_concept
+      &&
+      !static_require_concept<T, Property>::is_valid
+      &&
+      require_concept_member<T, Property>::is_valid
+    )
+  >::type> :
+  require_concept_member<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member);
+};
+
+template <typename T, typename Property>
+struct call_traits<T, void(Property),
+  typename enable_if<
+    (
+      is_applicable_property<
+        typename decay<T>::type,
+        typename decay<Property>::type
+      >::value
+      &&
+      decay<Property>::type::is_requirable_concept
+      &&
+      !static_require_concept<T, Property>::is_valid
+      &&
+      !require_concept_member<T, Property>::is_valid
+      &&
+      require_concept_free<T, Property>::is_valid
+    )
+  >::type> :
+  require_concept_free<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free);
+};
+
+struct impl
+{
+  template <typename T, typename Property>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(Property)>::overload == identity,
+    typename call_traits<T, void(Property)>::result_type
+  >::type
+  operator()(
+      ASIO_MOVE_ARG(T) t,
+      ASIO_MOVE_ARG(Property)) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<T, void(Property)>::is_noexcept))
+  {
+    return ASIO_MOVE_CAST(T)(t);
+  }
+
+  template <typename T, typename Property>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(Property)>::overload == call_member,
+    typename call_traits<T, void(Property)>::result_type
+  >::type
+  operator()(
+      ASIO_MOVE_ARG(T) t,
+      ASIO_MOVE_ARG(Property) p) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<T, void(Property)>::is_noexcept))
+  {
+    return ASIO_MOVE_CAST(T)(t).require_concept(
+        ASIO_MOVE_CAST(Property)(p));
+  }
+
+  template <typename T, typename Property>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(Property)>::overload == call_free,
+    typename call_traits<T, void(Property)>::result_type
+  >::type
+  operator()(
+      ASIO_MOVE_ARG(T) t,
+      ASIO_MOVE_ARG(Property) p) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<T, void(Property)>::is_noexcept))
+  {
+    return require_concept(
+        ASIO_MOVE_CAST(T)(t),
+        ASIO_MOVE_CAST(Property)(p));
+  }
+};
+
+template <typename T = impl>
+struct static_instance
+{
+  static const T instance;
+};
+
+template <typename T>
+const T static_instance<T>::instance = {};
+
+} // namespace asio_require_concept_fn
+namespace asio {
+namespace {
+
+static ASIO_CONSTEXPR const asio_require_concept_fn::impl&
+  require_concept = asio_require_concept_fn::static_instance<>::instance;
+
+} // namespace
+
+template <typename T, typename Property>
+struct can_require_concept :
+  integral_constant<bool,
+    asio_require_concept_fn::call_traits<T, void(Property)>::overload !=
+      asio_require_concept_fn::ill_formed>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+constexpr bool can_require_concept_v
+  = can_require_concept<T, Property>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+struct is_nothrow_require_concept :
+  integral_constant<bool,
+    asio_require_concept_fn::call_traits<T, void(Property)>::is_noexcept>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+constexpr bool is_nothrow_require_concept_v
+  = is_nothrow_require_concept<T, Property>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+struct require_concept_result
+{
+  typedef typename asio_require_concept_fn::call_traits<
+      T, void(Property)>::result_type type;
+};
+
+} // namespace asio
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_REQUIRE_CONCEPT_HPP

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

@@ -17,11 +17,11 @@
 
 #include "asio/detail/config.hpp"
 #include <boost/coroutine/all.hpp>
+#include "asio/any_io_executor.hpp"
 #include "asio/bind_executor.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/detail/wrapped_handler.hpp"
-#include "asio/executor.hpp"
 #include "asio/io_context.hpp"
 #include "asio/is_executor.hpp"
 #include "asio/strand.hpp"
@@ -151,7 +151,7 @@ private:
 typedef basic_yield_context<unspecified> yield_context;
 #else // defined(GENERATING_DOCUMENTATION)
 typedef basic_yield_context<
-  executor_binder<void(*)(), executor> > yield_context;
+  executor_binder<void(*)(), any_io_executor> > yield_context;
 #endif // defined(GENERATING_DOCUMENTATION)
 
 /**
@@ -225,7 +225,9 @@ void spawn(ASIO_MOVE_ARG(Handler) handler,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::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* = 0);
 
 /// Start a new stackful coroutine, inheriting the execution context of another.
@@ -266,7 +268,9 @@ void spawn(const Executor& ex,
     ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes(),
-    typename enable_if<is_executor<Executor>::value>::type* = 0);
+    typename enable_if<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type* = 0);
 
 /// Start a new stackful coroutine that executes on a given strand.
 /**
@@ -285,6 +289,8 @@ void spawn(const strand<Executor>& ex,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
 /// Start a new stackful coroutine that executes in the context of a strand.
 /**
  * This function is used to launch a new coroutine.
@@ -304,6 +310,8 @@ void spawn(const asio::io_context::strand& s,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
 /// Start a new stackful coroutine that executes on a given execution context.
 /**
  * This function is used to launch a new coroutine.

data/ext/third_party/asio/asio/include/asio/ssl/detail/buffered_handshake_op.hpp

@@ -29,6 +29,11 @@ template <typename ConstBufferSequence>
 class buffered_handshake_op
 {
 public:
+  static ASIO_CONSTEXPR const char* tracking_name()
+  {
+    return "ssl::stream<>::async_buffered_handshake";
+  }
+
   buffered_handshake_op(stream_base::handshake_type type,
       const ConstBufferSequence& buffers)
     : type_(type),

data/ext/third_party/asio/asio/include/asio/ssl/detail/engine.hpp

@@ -58,6 +58,11 @@ public:
   // Construct a new engine for the specified context.
   ASIO_DECL explicit engine(SSL_CTX* context);
 
+#if defined(ASIO_HAS_MOVE)
+  // Move construct from another engine.
+  ASIO_DECL engine(engine&& other) ASIO_NOEXCEPT;
+#endif // defined(ASIO_HAS_MOVE)
+
   // Destructor.
   ASIO_DECL ~engine();
 

data/ext/third_party/asio/asio/include/asio/ssl/detail/handshake_op.hpp

@@ -28,6 +28,11 @@ namespace detail {
 class handshake_op
 {
 public:
+  static ASIO_CONSTEXPR const char* tracking_name()
+  {
+    return "ssl::stream<>::async_handshake";
+  }
+
   handshake_op(stream_base::handshake_type type)
     : type_(type)
   {

data/ext/third_party/asio/asio/include/asio/ssl/detail/impl/engine.ipp

@@ -55,16 +55,29 @@ engine::engine(SSL_CTX* context)
   ::SSL_set_bio(ssl_, int_bio, int_bio);
 }
 
+#if defined(ASIO_HAS_MOVE)
+engine::engine(engine&& other) ASIO_NOEXCEPT
+  : ssl_(other.ssl_),
+    ext_bio_(other.ext_bio_)
+{
+  other.ssl_ = 0;
+  other.ext_bio_ = 0;
+}
+#endif // defined(ASIO_HAS_MOVE)
+
 engine::~engine()
 {
-  if (SSL_get_app_data(ssl_))
+  if (ssl_ && SSL_get_app_data(ssl_))
   {
     delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
     SSL_set_app_data(ssl_, 0);
   }
 
-  ::BIO_free(ext_bio_);
-  ::SSL_free(ssl_);
+  if (ext_bio_)
+    ::BIO_free(ext_bio_);
+
+  if (ssl_)
+    ::SSL_free(ssl_);
 }
 
 SSL* engine::native_handle()

data/ext/third_party/asio/asio/include/asio/ssl/detail/io.hpp

@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 
+#include "asio/detail/handler_tracking.hpp"
 #include "asio/ssl/detail/engine.hpp"
 #include "asio/ssl/detail/stream_core.hpp"
 #include "asio/write.hpp"
@@ -162,6 +163,9 @@ public:
             // Prevent other read operations from being started.
             core_.pending_read_.expires_at(core_.pos_infin());
 
+            ASIO_HANDLER_LOCATION((
+                  __FILE__, __LINE__, Operation::tracking_name()));
+
             // Start reading some data from the underlying transport.
             next_layer_.async_read_some(
                 asio::buffer(core_.input_buffer_),
@@ -169,6 +173,9 @@ public:
           }
           else
           {
+            ASIO_HANDLER_LOCATION((
+                  __FILE__, __LINE__, Operation::tracking_name()));
+
             // Wait until the current read operation completes.
             core_.pending_read_.async_wait(ASIO_MOVE_CAST(io_op)(*this));
           }
@@ -189,6 +196,9 @@ public:
             // Prevent other write operations from being started.
             core_.pending_write_.expires_at(core_.pos_infin());
 
+            ASIO_HANDLER_LOCATION((
+                  __FILE__, __LINE__, Operation::tracking_name()));
+
             // Start writing all the data to the underlying transport.
             asio::async_write(next_layer_,
                 core_.engine_.get_output(core_.output_buffer_),
@@ -196,6 +206,9 @@ public:
           }
           else
           {
+            ASIO_HANDLER_LOCATION((
+                  __FILE__, __LINE__, Operation::tracking_name()));
+
             // Wait until the current write operation completes.
             core_.pending_write_.async_wait(ASIO_MOVE_CAST(io_op)(*this));
           }
@@ -213,6 +226,9 @@ public:
           // read so the handler runs "as-if" posted using io_context::post().
           if (start)
           {
+            ASIO_HANDLER_LOCATION((
+                  __FILE__, __LINE__, Operation::tracking_name()));
+
             next_layer_.async_read_some(
                 asio::buffer(core_.input_buffer_, 0),
                 ASIO_MOVE_CAST(io_op)(*this));
@@ -293,19 +309,29 @@ public:
 };
 
 template <typename Stream, typename Operation, typename Handler>
-inline void* asio_handler_allocate(std::size_t size,
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
     io_op<Stream, Operation, 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 Stream, typename Operation, 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,
     io_op<Stream, Operation, 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 Stream, typename Operation, typename Handler>
@@ -318,20 +344,28 @@ inline bool asio_handler_is_continuation(
 
 template <typename Function, typename Stream,
     typename Operation, typename Handler>
-inline void asio_handler_invoke(Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
     io_op<Stream, Operation, 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 Stream,
     typename Operation, typename Handler>
-inline void asio_handler_invoke(const Function& function,
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
     io_op<Stream, Operation, 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 Stream, typename Operation, typename Handler>