couchbase 3.0.0 → 3.0.1

data/ext/third_party/asio/asio/include/asio/execution/schedule.hpp

@@ -0,0 +1,290 @@
+//
+// execution/schedule.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_EXECUTION_SCHEDULE_HPP
+#define ASIO_EXECUTION_SCHEDULE_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/execution/executor.hpp"
+#include "asio/traits/schedule_member.hpp"
+#include "asio/traits/schedule_free.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace asio {
+namespace execution {
+
+/// A customisation point that is used to obtain a sender from a scheduler.
+/**
+ * The name <tt>execution::schedule</tt> denotes a customisation point object.
+ * For some subexpression <tt>s</tt>, let <tt>S</tt> be a type such that
+ * <tt>decltype((s))</tt> is <tt>S</tt>. The expression
+ * <tt>execution::schedule(s)</tt> is expression-equivalent to:
+ *
+ * @li <tt>s.schedule()</tt>, if that expression is valid and its type models
+ *   <tt>sender</tt>.
+ *
+ * @li Otherwise, <tt>schedule(s)</tt>, if that expression is valid and its
+ *   type models <tt>sender</tt> with overload resolution performed in a context
+ *   that includes the declaration <tt>void schedule();</tt> and that does not
+ *   include a declaration of <tt>execution::schedule</tt>.
+ *
+ * @li Otherwise, <tt>S</tt> if <tt>S</tt> satisfies <tt>executor</tt>.
+ *
+ * @li Otherwise, <tt>execution::schedule(s)</tt> is ill-formed.
+ */
+inline constexpr unspecified schedule = unspecified;
+
+/// A type trait that determines whether a @c schedule expression is
+/// well-formed.
+/**
+ * Class template @c can_schedule is a trait that is derived from @c true_type
+ * if the expression <tt>execution::schedule(std::declval<S>())</tt> is well
+ * formed; otherwise @c false_type.
+ */
+template <typename S>
+struct can_schedule :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+} // namespace execution
+} // namespace asio
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace asio_execution_schedule_fn {
+
+using asio::decay;
+using asio::declval;
+using asio::enable_if;
+using asio::execution::is_executor;
+using asio::traits::schedule_free;
+using asio::traits::schedule_member;
+
+void schedule();
+
+enum overload_type
+{
+  identity,
+  call_member,
+  call_free,
+  ill_formed
+};
+
+template <typename S, 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 S>
+struct call_traits<S,
+  typename enable_if<
+    (
+      schedule_member<S>::is_valid
+    )
+  >::type> :
+  schedule_member<S>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member);
+};
+
+template <typename S>
+struct call_traits<S,
+  typename enable_if<
+    (
+      !schedule_member<S>::is_valid
+      &&
+      schedule_free<S>::is_valid
+    )
+  >::type> :
+  schedule_free<S>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free);
+};
+
+template <typename S>
+struct call_traits<S,
+  typename enable_if<
+    (
+      !schedule_member<S>::is_valid
+      &&
+      !schedule_free<S>::is_valid
+      &&
+      is_executor<typename decay<S>::type>::value
+    )
+  >::type>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
+
+#if defined(ASIO_HAS_MOVE)
+  typedef ASIO_MOVE_ARG(S) result_type;
+#else // defined(ASIO_HAS_MOVE)
+  typedef ASIO_MOVE_ARG(typename decay<S>::type) result_type;
+#endif // defined(ASIO_HAS_MOVE)
+};
+
+struct impl
+{
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<S>::overload == identity,
+    typename call_traits<S>::result_type
+  >::type
+  operator()(ASIO_MOVE_ARG(S) s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<S>::is_noexcept))
+  {
+    return ASIO_MOVE_CAST(S)(s);
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<S>::overload == call_member,
+    typename call_traits<S>::result_type
+  >::type
+  operator()(S&& s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<S>::is_noexcept))
+  {
+    return ASIO_MOVE_CAST(S)(s).schedule();
+  }
+
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<S>::overload == call_free,
+    typename call_traits<S>::result_type
+  >::type
+  operator()(S&& s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<S>::is_noexcept))
+  {
+    return schedule(ASIO_MOVE_CAST(S)(s));
+  }
+#else // defined(ASIO_HAS_MOVE)
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<S&>::overload == call_member,
+    typename call_traits<S&>::result_type
+  >::type
+  operator()(S& s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<S&>::is_noexcept))
+  {
+    return s.schedule();
+  }
+
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<const S&>::overload == call_member,
+    typename call_traits<const S&>::result_type
+  >::type
+  operator()(const S& s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<const S&>::is_noexcept))
+  {
+    return s.schedule();
+  }
+
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<S&>::overload == call_free,
+    typename call_traits<S&>::result_type
+  >::type
+  operator()(S& s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<S&>::is_noexcept))
+  {
+    return schedule(s);
+  }
+
+  template <typename S>
+  ASIO_CONSTEXPR typename enable_if<
+    call_traits<const S&>::overload == call_free,
+    typename call_traits<const S&>::result_type
+  >::type
+  operator()(const S& s) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<const S&>::is_noexcept))
+  {
+    return schedule(s);
+  }
+#endif // defined(ASIO_HAS_MOVE)
+};
+
+template <typename T = impl>
+struct static_instance
+{
+  static const T instance;
+};
+
+template <typename T>
+const T static_instance<T>::instance = {};
+
+} // namespace asio_execution_schedule_fn
+namespace asio {
+namespace execution {
+namespace {
+
+static ASIO_CONSTEXPR const asio_execution_schedule_fn::impl&
+  schedule = asio_execution_schedule_fn::static_instance<>::instance;
+
+} // namespace
+
+template <typename S>
+struct can_schedule :
+  integral_constant<bool,
+    asio_execution_schedule_fn::call_traits<S>::overload !=
+      asio_execution_schedule_fn::ill_formed>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S>
+constexpr bool can_schedule_v = can_schedule<S>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S>
+struct is_nothrow_schedule :
+  integral_constant<bool,
+    asio_execution_schedule_fn::call_traits<S>::is_noexcept>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S>
+constexpr bool is_nothrow_schedule_v
+  = is_nothrow_schedule<S>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+} // namespace execution
+} // namespace asio
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTION_SCHEDULE_HPP

data/ext/third_party/asio/asio/include/asio/execution/scheduler.hpp

@@ -0,0 +1,86 @@
+//
+// execution/scheduler.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_EXECUTION_SCHEDULER_HPP
+#define ASIO_EXECUTION_SCHEDULER_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/execution/schedule.hpp"
+#include "asio/traits/equality_comparable.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace execution {
+namespace detail {
+
+template <typename T>
+struct is_scheduler_base :
+  integral_constant<bool,
+    is_copy_constructible<typename remove_cvref<T>::type>::value
+      && traits::equality_comparable<typename remove_cvref<T>::type>::is_valid
+  >
+{
+};
+
+} // namespace detail
+
+/// The is_scheduler trait detects whether a type T satisfies the
+/// execution::scheduler concept.
+/**
+ * Class template @c is_scheduler is a type trait that is derived from @c
+ * true_type if the type @c T meets the concept definition for a scheduler for
+ * error type @c E, otherwise @c false_type.
+ */
+template <typename T>
+struct is_scheduler :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  conditional<
+    can_schedule<T>::value,
+    detail::is_scheduler_base<T>,
+    false_type
+  >::type
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T>
+ASIO_CONSTEXPR const bool is_scheduler_v = is_scheduler<T>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T>
+ASIO_CONCEPT scheduler = is_scheduler<T>::value;
+
+#define ASIO_EXECUTION_SCHEDULER ::asio::execution::scheduler
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_EXECUTION_SCHEDULER typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+} // namespace execution
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTION_SCHEDULER_HPP

data/ext/third_party/asio/asio/include/asio/execution/sender.hpp

@@ -0,0 +1,311 @@
+//
+// execution/sender.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_EXECUTION_SENDER_HPP
+#define ASIO_EXECUTION_SENDER_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/execution/detail/as_invocable.hpp"
+#include "asio/execution/detail/void_receiver.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/receiver.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(ASIO_HAS_ALIAS_TEMPLATES) \
+  && defined(ASIO_HAS_VARIADIC_TEMPLATES) \
+  && defined(ASIO_HAS_DECLTYPE) \
+  && !defined(ASIO_MSVC) || (_MSC_VER >= 1910)
+# define ASIO_HAS_DEDUCED_EXECUTION_IS_TYPED_SENDER_TRAIT 1
+#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
+       //   && defined(ASIO_HAS_VARIADIC_TEMPLATES)
+       //   && defined(ASIO_HAS_DECLTYPE)
+       //   && !defined(ASIO_MSVC) || (_MSC_VER >= 1910)
+
+namespace asio {
+namespace execution {
+namespace detail {
+
+namespace sender_base_ns { struct sender_base {}; }
+
+template <typename S, typename = void>
+struct sender_traits_base
+{
+  typedef void asio_execution_sender_traits_base_is_unspecialised;
+};
+
+template <typename S>
+struct sender_traits_base<S,
+    typename enable_if<
+      is_base_of<sender_base_ns::sender_base, S>::value
+    >::type>
+{
+};
+
+template <typename S, typename = void, typename = void, typename = void>
+struct has_sender_types : false_type
+{
+};
+
+#if defined(ASIO_HAS_DEDUCED_EXECUTION_IS_TYPED_SENDER_TRAIT)
+
+template <
+    template <
+      template <typename...> class Tuple,
+      template <typename...> class Variant
+    > class>
+struct has_value_types
+{
+  typedef void type;
+};
+
+template <
+  template <
+    template <typename...> class Variant
+  > class>
+struct has_error_types
+{
+  typedef void type;
+};
+
+template <typename S>
+struct has_sender_types<S,
+    typename has_value_types<S::template value_types>::type,
+    typename has_error_types<S::template error_types>::type,
+    typename conditional<S::sends_done, void, void>::type> : true_type
+{
+};
+
+template <typename S>
+struct sender_traits_base<S,
+    typename enable_if<
+      has_sender_types<S>::value
+    >::type>
+{
+  template <
+      template <typename...> class Tuple,
+      template <typename...> class Variant>
+  using value_types = typename S::template value_types<Tuple, Variant>;
+
+  template <template <typename...> class Variant>
+  using error_types = typename S::template error_types<Variant>;
+
+  ASIO_STATIC_CONSTEXPR(bool, sends_done = S::sends_done);
+};
+
+#endif // defined(ASIO_HAS_DEDUCED_EXECUTION_IS_TYPED_SENDER_TRAIT)
+
+template <typename S>
+struct sender_traits_base<S,
+    typename enable_if<
+      !has_sender_types<S>::value
+        && detail::is_executor_of_impl<S,
+          as_invocable<void_receiver, S> >::value
+    >::type>
+{
+#if defined(ASIO_HAS_DEDUCED_EXECUTION_IS_TYPED_SENDER_TRAIT) \
+  && defined(ASIO_HAS_STD_EXCEPTION_PTR)
+
+  template <
+      template <typename...> class Tuple,
+      template <typename...> class Variant>
+  using value_types = Variant<Tuple<>>;
+
+  template <template <typename...> class Variant>
+  using error_types = Variant<std::exception_ptr>;
+
+  ASIO_STATIC_CONSTEXPR(bool, sends_done = true);
+
+#endif // defined(ASIO_HAS_DEDUCED_EXECUTION_IS_TYPED_SENDER_TRAIT)
+       //   && defined(ASIO_HAS_STD_EXCEPTION_PTR)
+};
+
+} // namespace detail
+
+/// Base class used for tagging senders.
+#if defined(GENERATING_DOCUMENTATION)
+typedef unspecified sender_base;
+#else // defined(GENERATING_DOCUMENTATION)
+typedef detail::sender_base_ns::sender_base sender_base;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+/// Traits for senders.
+template <typename S>
+struct sender_traits
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::sender_traits_base<S>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+};
+
+namespace detail {
+
+template <typename S, typename = void>
+struct has_sender_traits : true_type
+{
+};
+
+template <typename S>
+struct has_sender_traits<S,
+    typename enable_if<
+      is_same<
+        typename asio::execution::sender_traits<
+          S>::asio_execution_sender_traits_base_is_unspecialised,
+        void
+      >::value
+    >::type> : false_type
+{
+};
+
+} // namespace detail
+
+/// The is_sender trait detects whether a type T satisfies the
+/// execution::sender concept.
+
+/**
+ * Class template @c is_sender is a type trait that is derived from @c
+ * true_type if the type @c T meets the concept definition for a sender,
+ * otherwise @c false_type.
+ */
+template <typename T>
+struct is_sender :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  conditional<
+    detail::has_sender_traits<typename remove_cvref<T>::type>::value,
+    is_move_constructible<typename remove_cvref<T>::type>,
+    false_type
+  >::type
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T>
+ASIO_CONSTEXPR const bool is_sender_v = is_sender<T>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T>
+ASIO_CONCEPT sender = is_sender<T>::value;
+
+#define ASIO_EXECUTION_SENDER ::asio::execution::sender
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_EXECUTION_SENDER typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+template <typename S, typename R>
+struct can_connect;
+
+/// The is_sender_to trait detects whether a type T satisfies the
+/// execution::sender_to concept for some receiver.
+/**
+ * Class template @c is_sender_to is a type trait that is derived from @c
+ * true_type if the type @c T meets the concept definition for a sender
+ * for some receiver type R, otherwise @c false.
+ */
+template <typename T, typename R>
+struct is_sender_to :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool,
+    is_sender<T>::value
+      && is_receiver<R>::value
+      && can_connect<T, R>::value
+  >
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename R>
+ASIO_CONSTEXPR const bool is_sender_to_v =
+  is_sender_to<T, R>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T, typename R>
+ASIO_CONCEPT sender_to = is_sender_to<T, R>::value;
+
+#define ASIO_EXECUTION_SENDER_TO(r) \
+  ::asio::execution::sender_to<r>
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_EXECUTION_SENDER_TO(r) typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+/// The is_typed_sender trait detects whether a type T satisfies the
+/// execution::typed_sender concept.
+/**
+ * Class template @c is_typed_sender is a type trait that is derived from @c
+ * true_type if the type @c T meets the concept definition for a typed sender,
+ * otherwise @c false.
+ */
+template <typename T>
+struct is_typed_sender :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool,
+    is_sender<T>::value
+      && detail::has_sender_types<
+        sender_traits<typename remove_cvref<T>::type> >::value
+  >
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T>
+ASIO_CONSTEXPR const bool is_typed_sender_v = is_typed_sender<T>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T>
+ASIO_CONCEPT typed_sender = is_typed_sender<T>::value;
+
+#define ASIO_EXECUTION_TYPED_SENDER \
+  ::asio::execution::typed_sender
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_EXECUTION_TYPED_SENDER typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+} // namespace execution
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/execution/connect.hpp"
+
+#endif // ASIO_EXECUTION_SENDER_HPP