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

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

@@ -0,0 +1,327 @@
+//
+// execution/prefer_only.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_PREFER_ONLY_HPP
+#define ASIO_EXECUTION_PREFER_ONLY_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/prefer.hpp"
+#include "asio/query.hpp"
+#include "asio/traits/static_query.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace execution {
+
+/// A property adapter that is used with the polymorphic executor wrapper
+/// to mark properties as preferable, but not requirable.
+template <typename Property>
+struct prefer_only
+{
+  /// The prefer_only adapter applies to the same types as the nested property.
+  template <typename T>
+  static constexpr bool is_applicable_property_v =
+    is_applicable_property<T, Property>::value;
+
+  /// The context_t property cannot be required.
+  static constexpr bool is_requirable = false;
+
+  /// The context_t property can be preferred, it the underlying property can
+  /// be preferred.
+  /**
+   * @c true if @c Property::is_preferable is @c true, otherwise @c false.
+   */
+  static constexpr bool is_preferable = automatically_determined;
+
+  /// The type returned by queries against an @c any_executor.
+  typedef typename Property::polymorphic_query_result_type
+    polymorphic_query_result_type;
+};
+
+} // namespace execution
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace execution {
+namespace detail {
+
+template <typename InnerProperty, typename = void>
+struct prefer_only_is_preferable
+{
+  ASIO_STATIC_CONSTEXPR(bool, is_preferable = false);
+};
+
+template <typename InnerProperty>
+struct prefer_only_is_preferable<InnerProperty,
+    typename enable_if<
+      InnerProperty::is_preferable
+    >::type>
+{
+  ASIO_STATIC_CONSTEXPR(bool, is_preferable = true);
+};
+
+template <typename InnerProperty, typename = void>
+struct prefer_only_polymorphic_query_result_type
+{
+};
+
+template <typename InnerProperty>
+struct prefer_only_polymorphic_query_result_type<InnerProperty,
+    typename void_type<
+      typename InnerProperty::polymorphic_query_result_type
+    >::type>
+{
+  typedef typename InnerProperty::polymorphic_query_result_type
+    polymorphic_query_result_type;
+};
+
+template <typename InnerProperty, typename = void>
+struct prefer_only_property
+{
+  InnerProperty property;
+
+  prefer_only_property(const InnerProperty& p)
+    : property(p)
+  {
+  }
+};
+
+#if defined(ASIO_HAS_DECLTYPE) \
+  && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
+
+template <typename InnerProperty>
+struct prefer_only_property<InnerProperty,
+    typename void_type<
+      decltype(asio::declval<const InnerProperty>().value())
+    >::type>
+{
+  InnerProperty property;
+
+  prefer_only_property(const InnerProperty& p)
+    : property(p)
+  {
+  }
+
+  ASIO_CONSTEXPR auto value() const
+    ASIO_NOEXCEPT_IF((
+      noexcept(asio::declval<const InnerProperty>().value())))
+    -> decltype(asio::declval<const InnerProperty>().value())
+  {
+    return property.value();
+  }
+};
+
+#else // defined(ASIO_HAS_DECLTYPE)
+      //   && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
+
+struct prefer_only_memfns_base
+{
+  void value();
+};
+
+template <typename T>
+struct prefer_only_memfns_derived
+  : T, prefer_only_memfns_base
+{
+};
+
+template <typename T, T>
+struct prefer_only_memfns_check
+{
+};
+
+template <typename>
+char (&prefer_only_value_memfn_helper(...))[2];
+
+template <typename T>
+char prefer_only_value_memfn_helper(
+    prefer_only_memfns_check<
+      void (prefer_only_memfns_base::*)(),
+      &prefer_only_memfns_derived<T>::value>*);
+
+template <typename InnerProperty>
+struct prefer_only_property<InnerProperty,
+    typename enable_if<
+      sizeof(prefer_only_value_memfn_helper<InnerProperty>(0)) != 1
+        && !is_same<typename InnerProperty::polymorphic_query_result_type,
+          void>::value
+    >::type>
+{
+  InnerProperty property;
+
+  prefer_only_property(const InnerProperty& p)
+    : property(p)
+  {
+  }
+
+  ASIO_CONSTEXPR typename InnerProperty::polymorphic_query_result_type
+  value() const
+  {
+    return property.value();
+  }
+};
+
+#endif // defined(ASIO_HAS_DECLTYPE)
+       //   && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
+
+} // namespace detail
+
+template <typename InnerProperty>
+struct prefer_only :
+  detail::prefer_only_is_preferable<InnerProperty>,
+  detail::prefer_only_polymorphic_query_result_type<InnerProperty>,
+  detail::prefer_only_property<InnerProperty>
+{
+  ASIO_STATIC_CONSTEXPR(bool, is_requirable = false);
+
+  ASIO_CONSTEXPR prefer_only(const InnerProperty& p)
+    : detail::prefer_only_property<InnerProperty>(p)
+  {
+  }
+
+#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+  template <typename T>
+  static ASIO_CONSTEXPR
+  typename traits::static_query<T, InnerProperty>::result_type
+  static_query()
+    ASIO_NOEXCEPT_IF((
+      traits::static_query<T, InnerProperty>::is_noexcept))
+  {
+    return traits::static_query<T, InnerProperty>::value();
+  }
+
+  template <typename E, typename T = decltype(prefer_only::static_query<E>())>
+  static ASIO_CONSTEXPR const T static_query_v
+    = prefer_only::static_query<E>();
+#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+  template <typename Executor, typename Property>
+  friend ASIO_CONSTEXPR
+  typename prefer_result<const Executor&, const InnerProperty&>::type
+  prefer(const Executor& ex, const prefer_only<Property>& p,
+      typename enable_if<
+        is_same<Property, InnerProperty>::value
+          && can_prefer<const Executor&, const InnerProperty&>::value
+      >::type* = 0)
+#if !defined(ASIO_MSVC) \
+  && !defined(__clang__) // Clang crashes if noexcept is used here.
+    ASIO_NOEXCEPT_IF((
+      is_nothrow_prefer<const Executor&, const InnerProperty&>::value))
+#endif // !defined(ASIO_MSVC)
+       //   && !defined(__clang__)
+  {
+    return asio::prefer(ex, p.property);
+  }
+
+  template <typename Executor, typename Property>
+  friend ASIO_CONSTEXPR
+  typename query_result<const Executor&, const InnerProperty&>::type
+  query(const Executor& ex, const prefer_only<Property>& p,
+      typename enable_if<
+        is_same<Property, InnerProperty>::value
+          && can_query<const Executor&, const InnerProperty&>::value
+      >::type* = 0)
+#if !defined(ASIO_MSVC) \
+  && !defined(__clang__) // Clang crashes if noexcept is used here.
+    ASIO_NOEXCEPT_IF((
+      is_nothrow_query<const Executor&, const InnerProperty&>::value))
+#endif // !defined(ASIO_MSVC)
+       //   && !defined(__clang__)
+  {
+    return asio::query(ex, p.property);
+  }
+};
+
+#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+template <typename InnerProperty> template <typename E, typename T>
+const T prefer_only<InnerProperty>::static_query_v;
+#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+} // namespace execution
+
+template <typename T, typename InnerProperty>
+struct is_applicable_property<T, execution::prefer_only<InnerProperty> >
+  : is_applicable_property<T, InnerProperty>
+{
+};
+
+namespace traits {
+
+#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+template <typename T, typename InnerProperty>
+struct static_query<T, execution::prefer_only<InnerProperty> > :
+  static_query<T, const InnerProperty&>
+{
+};
+
+#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
+
+template <typename T, typename InnerProperty>
+struct prefer_free_default<T, execution::prefer_only<InnerProperty>,
+    typename enable_if<
+      can_prefer<const T&, const InnerProperty&>::value
+    >::type>
+{
+  ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
+    (is_nothrow_prefer<const T&, const InnerProperty&>::value));
+
+  typedef typename prefer_result<const T&,
+      const InnerProperty&>::type result_type;
+};
+
+#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
+
+#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
+
+template <typename T, typename InnerProperty>
+struct query_free<T, execution::prefer_only<InnerProperty>,
+    typename enable_if<
+      can_query<const T&, const InnerProperty&>::value
+    >::type>
+{
+  ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
+    (is_nothrow_query<const T&, const InnerProperty&>::value));
+
+  typedef typename query_result<const T&,
+      const InnerProperty&>::type result_type;
+};
+
+#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
+
+} // namespace traits
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTION_PREFER_ONLY_HPP

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

@@ -0,0 +1,280 @@
+//
+// execution/receiver.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_RECEIVER_HPP
+#define ASIO_EXECUTION_RECEIVER_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/detail/variadic_templates.hpp"
+#include "asio/execution/set_done.hpp"
+#include "asio/execution/set_error.hpp"
+#include "asio/execution/set_value.hpp"
+
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR)
+# include <exception>
+#else // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+# include "asio/error_code.hpp"
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+
+#if defined(ASIO_HAS_DEDUCED_SET_DONE_FREE_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_SET_DONE_MEMBER_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_SET_VALUE_FREE_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_SET_VALUE_MEMBER_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_RECEIVER_OF_FREE_TRAIT) \
+  && defined(ASIO_HAS_DEDUCED_RECEIVER_OF_MEMBER_TRAIT)
+# define ASIO_HAS_DEDUCED_EXECUTION_IS_RECEIVER_TRAIT 1
+#endif // defined(ASIO_HAS_DEDUCED_SET_DONE_FREE_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_SET_DONE_MEMBER_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_SET_VALUE_FREE_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_SET_VALUE_MEMBER_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_RECEIVER_OF_FREE_TRAIT)
+       //   && defined(ASIO_HAS_DEDUCED_RECEIVER_OF_MEMBER_TRAIT)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace execution {
+namespace detail {
+
+template <typename T, typename E>
+struct is_receiver_base :
+  integral_constant<bool,
+    is_move_constructible<typename remove_cvref<T>::type>::value
+      && is_constructible<typename remove_cvref<T>::type, T>::value
+  >
+{
+};
+
+} // namespace detail
+
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR)
+# define ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT = std::exception_ptr
+#else // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+# define ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT \
+  = ::asio::error_code
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+
+/// The is_receiver trait detects whether a type T satisfies the
+/// execution::receiver concept.
+/**
+ * Class template @c is_receiver is a type trait that is derived from @c
+ * true_type if the type @c T meets the concept definition for a receiver for
+ * error type @c E, otherwise @c false_type.
+ */
+template <typename T, typename E ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT>
+struct is_receiver :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  conditional<
+    can_set_done<typename remove_cvref<T>::type>::value
+      && is_nothrow_set_done<typename remove_cvref<T>::type>::value
+      && can_set_error<typename remove_cvref<T>::type, E>::value
+      && is_nothrow_set_error<typename remove_cvref<T>::type, E>::value,
+    detail::is_receiver_base<T, E>,
+    false_type
+  >::type
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename E ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT>
+ASIO_CONSTEXPR const bool is_receiver_v = is_receiver<T, E>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T, typename E ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT>
+ASIO_CONCEPT receiver = is_receiver<T, E>::value;
+
+#define ASIO_EXECUTION_RECEIVER ::asio::execution::receiver
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_EXECUTION_RECEIVER typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// The is_receiver_of trait detects whether a type T satisfies the
+/// execution::receiver_of concept for some set of value arguments.
+/**
+ * Class template @c is_receiver_of is a type trait that is derived from @c
+ * true_type if the type @c T meets the concept definition for a receiver for
+ * value arguments @c Vs, otherwise @c false_type.
+ */
+template <typename T, typename... Vs>
+struct is_receiver_of :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  conditional<
+    is_receiver<T>::value,
+    can_set_value<typename remove_cvref<T>::type, Vs...>,
+    false_type
+  >::type
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename... Vs>
+ASIO_CONSTEXPR const bool is_receiver_of_v =
+  is_receiver_of<T, Vs...>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T, typename... Vs>
+ASIO_CONCEPT receiver_of = is_receiver_of<T, Vs...>::value;
+
+#define ASIO_EXECUTION_RECEIVER_OF_0 \
+  ::asio::execution::receiver_of
+
+#define ASIO_EXECUTION_RECEIVER_OF_1(v) \
+  ::asio::execution::receiver_of<v>
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_EXECUTION_RECEIVER_OF_0 typename
+#define ASIO_EXECUTION_RECEIVER_OF_1(v) typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+      //   || defined(GENERATING_DOCUMENTATION)
+
+template <typename T, typename = void,
+    typename = void, typename = void, typename = void, typename = void,
+    typename = void, typename = void, typename = void, typename = void>
+struct is_receiver_of;
+
+template <typename T>
+struct is_receiver_of<T> :
+  conditional<
+    is_receiver<T>::value,
+    can_set_value<typename remove_cvref<T>::type>,
+    false_type
+  >::type
+{
+};
+
+#define ASIO_PRIVATE_RECEIVER_OF_TRAITS_DEF(n) \
+  template <typename T, ASIO_VARIADIC_TPARAMS(n)> \
+  struct is_receiver_of<T, ASIO_VARIADIC_TARGS(n)> : \
+    conditional< \
+      conditional<true, is_receiver<T>, void>::type::value, \
+      can_set_value< \
+        typename remove_cvref<T>::type, \
+        ASIO_VARIADIC_TARGS(n)>, \
+      false_type \
+    >::type \
+  { \
+  }; \
+  /**/
+ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_RECEIVER_OF_TRAITS_DEF)
+#undef ASIO_PRIVATE_RECEIVER_OF_TRAITS_DEF
+
+#define ASIO_EXECUTION_RECEIVER_OF_0 typename
+#define ASIO_EXECUTION_RECEIVER_OF_1(v) typename
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// The is_nothrow_receiver_of trait detects whether a type T satisfies the
+/// execution::receiver_of concept for some set of value arguments, with a
+/// noexcept @c set_value operation.
+/**
+ * Class template @c is_nothrow_receiver_of is a type trait that is derived
+ * from @c true_type if the type @c T meets the concept definition for a
+ * receiver for value arguments @c Vs, and the expression
+ * <tt>execution::set_value(declval<T>(), declval<Ts>()...)</tt> is noexcept,
+ * otherwise @c false_type.
+ */
+template <typename T, typename... Vs>
+struct is_nothrow_receiver_of :
+#if defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool, automatically_determined>
+#else // defined(GENERATING_DOCUMENTATION)
+  integral_constant<bool,
+    is_receiver_of<T, Vs...>::value
+      && is_nothrow_set_value<typename remove_cvref<T>::type, Vs...>::value
+  >
+#endif // defined(GENERATING_DOCUMENTATION)
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename... Vs>
+ASIO_CONSTEXPR const bool is_nothrow_receiver_of_v =
+  is_nothrow_receiver_of<T, Vs...>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+      //   || defined(GENERATING_DOCUMENTATION)
+
+template <typename T, typename = void,
+    typename = void, typename = void, typename = void, typename = void,
+    typename = void, typename = void, typename = void, typename = void>
+struct is_nothrow_receiver_of;
+
+template <typename T>
+struct is_nothrow_receiver_of<T> :
+  integral_constant<bool,
+    is_receiver_of<T>::value
+      && is_nothrow_set_value<typename remove_cvref<T>::type>::value
+  >
+{
+};
+
+#define ASIO_PRIVATE_NOTHROW_RECEIVER_OF_TRAITS_DEF(n) \
+  template <typename T, ASIO_VARIADIC_TPARAMS(n)> \
+  struct is_nothrow_receiver_of<T, ASIO_VARIADIC_TARGS(n)> : \
+    integral_constant<bool, \
+      is_receiver_of<T, ASIO_VARIADIC_TARGS(n)>::value \
+        && is_nothrow_set_value<typename remove_cvref<T>::type, \
+          ASIO_VARIADIC_TARGS(n)>::value \
+    > \
+  { \
+  }; \
+  /**/
+ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_NOTHROW_RECEIVER_OF_TRAITS_DEF)
+#undef ASIO_PRIVATE_NOTHROW_RECEIVER_OF_TRAITS_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+} // namespace execution
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTION_RECEIVER_HPP