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

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

@@ -17,7 +17,8 @@
 
 #include "asio/detail/config.hpp"
 
-#if !defined(ASIO_NO_EXTENSIONS)
+#if !defined(ASIO_NO_EXTENSIONS) \
+  && !defined(ASIO_NO_TS_EXECUTORS)
 
 #include "asio/async_result.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
@@ -370,5 +371,6 @@ private:
 #include "asio/detail/pop_options.hpp"
 
 #endif // !defined(ASIO_NO_EXTENSIONS)
+       //   && !defined(ASIO_NO_TS_EXECUTORS)
 
 #endif // ASIO_IO_CONTEXT_STRAND_HPP

data/ext/third_party/asio/asio/include/asio/ip/basic_resolver.hpp

@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 #include <string>
+#include "asio/any_io_executor.hpp"
 #include "asio/async_result.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/io_object_impl.hpp"
@@ -25,7 +26,6 @@
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
 #include "asio/execution_context.hpp"
-#include "asio/executor.hpp"
 #include "asio/ip/basic_resolver_iterator.hpp"
 #include "asio/ip/basic_resolver_query.hpp"
 #include "asio/ip/basic_resolver_results.hpp"
@@ -49,7 +49,7 @@ namespace ip {
 #define ASIO_IP_BASIC_RESOLVER_FWD_DECL
 
 // Forward declaration with defaulted arguments.
-template <typename InternetProtocol, typename Executor = executor>
+template <typename InternetProtocol, typename Executor = any_io_executor>
 class basic_resolver;
 
 #endif // !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL)
@@ -1003,8 +1003,8 @@ private:
 
       asio::detail::non_const_lvalue<ResolveHandler> handler2(handler);
       self_->impl_.get_service().async_resolve(
-          self_->impl_.get_implementation(), q, handler2.value,
-          self_->impl_.get_implementation_executor());
+          self_->impl_.get_implementation(), q,
+          handler2.value, self_->impl_.get_executor());
     }
 
   private:

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

@@ -0,0 +1,61 @@
+//
+// is_applicable_property.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_IS_APPLICABLE_PROPERTY_HPP
+#define ASIO_IS_APPLICABLE_PROPERTY_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"
+
+namespace asio {
+namespace detail {
+
+template <typename T, typename Property, typename = void>
+struct is_applicable_property_trait : false_type
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+struct is_applicable_property_trait<T, Property,
+  typename void_type<
+    typename enable_if<
+      !!Property::template is_applicable_property_v<T>
+    >::type
+  >::type> : true_type
+{
+};
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+} // namespace detail
+
+template <typename T, typename Property, typename = void>
+struct is_applicable_property :
+  detail::is_applicable_property_trait<T, Property>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+ASIO_CONSTEXPR const bool is_applicable_property_v
+  = is_applicable_property<T, Property>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+} // namespace asio
+
+#endif // ASIO_IS_APPLICABLE_PROPERTY_HPP

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

@@ -0,0 +1,58 @@
+//
+// multiple_exceptions.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_MULTIPLE_EXCEPTIONS_HPP
+#define ASIO_MULTIPLE_EXCEPTIONS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <exception>
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Exception thrown when there are multiple pending exceptions to rethrow.
+class multiple_exceptions
+  : public std::exception
+{
+public:
+  /// Constructor.
+  ASIO_DECL multiple_exceptions(
+      std::exception_ptr first) ASIO_NOEXCEPT;
+
+  /// Obtain message associated with exception.
+  ASIO_DECL virtual const char* what() const
+    ASIO_NOEXCEPT_OR_NOTHROW;
+
+  /// Obtain a pointer to the first exception.
+  ASIO_DECL std::exception_ptr first_exception() const;
+
+private:
+  std::exception_ptr first_;
+};
+
+#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/multiple_exceptions.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_MULTIPLE_EXCEPTIONS_HPP

data/ext/third_party/asio/asio/include/asio/posix/basic_descriptor.hpp

@@ -20,6 +20,7 @@
 #if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
+#include "asio/any_io_executor.hpp"
 #include "asio/async_result.hpp"
 #include "asio/detail/handler_type_requirements.hpp"
 #include "asio/detail/io_object_impl.hpp"
@@ -28,7 +29,6 @@
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
 #include "asio/execution_context.hpp"
-#include "asio/executor.hpp"
 #include "asio/posix/descriptor_base.hpp"
 
 #if defined(ASIO_HAS_MOVE)
@@ -49,7 +49,7 @@ namespace posix {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
-template <typename Executor = executor>
+template <typename Executor = any_io_executor>
 class basic_descriptor
   : public descriptor_base
 {
@@ -677,8 +677,8 @@ private:
 
       detail::non_const_lvalue<WaitHandler> handler2(handler);
       self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(), w, handler2.value,
-          self_->impl_.get_implementation_executor());
+          self_->impl_.get_implementation(), w,
+          handler2.value, self_->impl_.get_executor());
     }
 
   private:

data/ext/third_party/asio/asio/include/asio/posix/basic_stream_descriptor.hpp

@@ -36,7 +36,7 @@ namespace posix {
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
-template <typename Executor = executor>
+template <typename Executor = any_io_executor>
 class basic_stream_descriptor
   : public basic_descriptor<Executor>
 {
@@ -419,8 +419,8 @@ private:
 
       detail::non_const_lvalue<WriteHandler> handler2(handler);
       self_->impl_.get_service().async_write_some(
-          self_->impl_.get_implementation(), buffers, handler2.value,
-          self_->impl_.get_implementation_executor());
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
     }
 
   private:
@@ -452,8 +452,8 @@ private:
 
       detail::non_const_lvalue<ReadHandler> handler2(handler);
       self_->impl_.get_service().async_read_some(
-          self_->impl_.get_implementation(), buffers, handler2.value,
-          self_->impl_.get_implementation_executor());
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
     }
 
   private:

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

@@ -19,6 +19,7 @@
 #include "asio/async_result.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/execution_context.hpp"
+#include "asio/execution/executor.hpp"
 #include "asio/is_executor.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -96,7 +97,9 @@ ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
     const Executor& ex,
     ASIO_MOVE_ARG(CompletionToken) token
       ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    typename enable_if<is_executor<Executor>::value>::type* = 0);
+    typename enable_if<
+      execution::is_executor<Executor>::value || is_executor<Executor>::value
+    >::type* = 0);
 
 /// Submits a completion token or function object for execution.
 /**

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

@@ -0,0 +1,656 @@
+//
+// prefer.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_PREFER_HPP
+#define ASIO_PREFER_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/prefer_free.hpp"
+#include "asio/traits/prefer_member.hpp"
+#include "asio/traits/require_free.hpp"
+#include "asio/traits/require_member.hpp"
+#include "asio/traits/static_require.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace asio {
+
+/// A customisation point that attempts to apply a property to an object.
+/**
+ * The name <tt>prefer</tt> denotes a customisation point object. The
+ * expression <tt>asio::prefer(E, P0, Pn...)</tt> for some subexpressions
+ * <tt>E</tt> and <tt>P0</tt>, and where <tt>Pn...</tt> represents <tt>N</tt>
+ * subexpressions (where <tt>N</tt> is 0 or more, and with types <tt>T =
+ * decay_t<decltype(E)></tt> and <tt>Prop0 = decay_t<decltype(P0)></tt>) is
+ * expression-equivalent to:
+ *
+ * @li If <tt>is_applicable_property_v<T, Prop0> && Prop0::is_preferable</tt> is
+ *   not a well-formed constant expression with value <tt>true</tt>,
+ *   <tt>asio::prefer(E, P0, Pn...)</tt> is ill-formed.
+ *
+ * @li Otherwise, <tt>E</tt> if <tt>N == 0</tt> and the expression
+ *   <tt>Prop0::template static_query_v<T> == Prop0::value()</tt> is a
+ *   well-formed constant expression with value <tt>true</tt>.
+ *
+ * @li Otherwise, <tt>(E).require(P0)</tt> if <tt>N == 0</tt> and the expression
+ *   <tt>(E).require(P0)</tt> is a valid expression.
+ *
+ * @li Otherwise, <tt>require(E, P0)</tt> if <tt>N == 0</tt> and the expression
+ *   <tt>require(E, P0)</tt> is a valid expression with overload resolution
+ *   performed in a context that does not include the declaration of the
+ *   <tt>require</tt> customization point object.
+ *
+ * @li Otherwise, <tt>(E).prefer(P0)</tt> if <tt>N == 0</tt> and the expression
+ *   <tt>(E).prefer(P0)</tt> is a valid expression.
+ *
+ * @li Otherwise, <tt>prefer(E, P0)</tt> if <tt>N == 0</tt> and the expression
+ *   <tt>prefer(E, P0)</tt> is a valid expression with overload resolution
+ *   performed in a context that does not include the declaration of the
+ *   <tt>prefer</tt> customization point object.
+ *
+ * @li Otherwise, <tt>E</tt> if <tt>N == 0</tt>.
+ *
+ * @li Otherwise,
+ *   <tt>asio::prefer(asio::prefer(E, P0), Pn...)</tt>
+ *   if <tt>N > 0</tt> and the expression
+ *   <tt>asio::prefer(asio::prefer(E, P0), Pn...)</tt>
+ *   is a valid expression.
+ *
+ * @li Otherwise, <tt>asio::prefer(E, P0, Pn...)</tt> is ill-formed.
+ */
+inline constexpr unspecified prefer = unspecified;
+
+/// A type trait that determines whether a @c prefer expression is well-formed.
+/**
+ * Class template @c can_prefer is a trait that is derived from
+ * @c true_type if the expression <tt>asio::prefer(std::declval<T>(),
+ * std::declval<Properties>()...)</tt> is well formed; otherwise @c false_type.
+ */
+template <typename T, typename... Properties>
+struct can_prefer :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines whether a @c prefer expression will not throw.
+/**
+ * Class template @c is_nothrow_prefer is a trait that is derived from
+ * @c true_type if the expression <tt>asio::prefer(std::declval<T>(),
+ * std::declval<Properties>()...)</tt> is @c noexcept; otherwise @c false_type.
+ */
+template <typename T, typename... Properties>
+struct is_nothrow_prefer :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines the result type of a @c prefer expression.
+/**
+ * Class template @c prefer_result is a trait that determines the result
+ * type of the expression <tt>asio::prefer(std::declval<T>(),
+ * std::declval<Properties>()...)</tt>.
+ */
+template <typename T, typename... Properties>
+struct prefer_result
+{
+  /// The result of the @c prefer expression.
+  typedef automatically_determined type;
+};
+
+} // namespace asio
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace asio_prefer_fn {
+
+using asio::decay;
+using asio::declval;
+using asio::enable_if;
+using asio::is_applicable_property;
+using asio::traits::prefer_free;
+using asio::traits::prefer_member;
+using asio::traits::require_free;
+using asio::traits::require_member;
+using asio::traits::static_require;
+
+void prefer();
+void require();
+
+enum overload_type
+{
+  identity,
+  call_require_member,
+  call_require_free,
+  call_prefer_member,
+  call_prefer_free,
+  two_props,
+  n_props,
+  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_preferable
+      &&
+      static_require<T, Property>::is_valid
+    )
+  >::type>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
+
+#if defined(ASIO_HAS_MOVE)
+  typedef ASIO_MOVE_ARG(T) result_type;
+#else // defined(ASIO_HAS_MOVE)
+  typedef ASIO_MOVE_ARG(typename decay<T>::type) result_type;
+#endif // defined(ASIO_HAS_MOVE)
+};
+
+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_preferable
+      &&
+      !static_require<T, Property>::is_valid
+      &&
+      require_member<T, Property>::is_valid
+    )
+  >::type> :
+  require_member<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_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_preferable
+      &&
+      !static_require<T, Property>::is_valid
+      &&
+      !require_member<T, Property>::is_valid
+      &&
+      require_free<T, Property>::is_valid
+    )
+  >::type> :
+  require_free<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_free);
+};
+
+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_preferable
+      &&
+      !static_require<T, Property>::is_valid
+      &&
+      !require_member<T, Property>::is_valid
+      &&
+      !require_free<T, Property>::is_valid
+      &&
+      prefer_member<T, Property>::is_valid
+    )
+  >::type> :
+  prefer_member<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_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_preferable
+      &&
+      !static_require<T, Property>::is_valid
+      &&
+      !require_member<T, Property>::is_valid
+      &&
+      !require_free<T, Property>::is_valid
+      &&
+      !prefer_member<T, Property>::is_valid
+      &&
+      prefer_free<T, Property>::is_valid
+    )
+  >::type> :
+  prefer_free<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_free);
+};
+
+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_preferable
+      &&
+      !static_require<T, Property>::is_valid
+      &&
+      !require_member<T, Property>::is_valid
+      &&
+      !require_free<T, Property>::is_valid
+      &&
+      !prefer_member<T, Property>::is_valid
+      &&
+      !prefer_free<T, Property>::is_valid
+    )
+  >::type>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
+
+#if defined(ASIO_HAS_MOVE)
+  typedef ASIO_MOVE_ARG(T) result_type;
+#else // defined(ASIO_HAS_MOVE)
+  typedef ASIO_MOVE_ARG(typename decay<T>::type) result_type;
+#endif // defined(ASIO_HAS_MOVE)
+};
+
+template <typename T, typename P0, typename P1>
+struct call_traits<T, void(P0, P1),
+  typename enable_if<
+    call_traits<T, void(P0)>::overload != ill_formed
+    &&
+    call_traits<
+      typename call_traits<T, void(P0)>::result_type,
+      void(P1)
+    >::overload != ill_formed
+  >::type>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = two_props);
+
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
+    (
+      call_traits<T, void(P0)>::is_noexcept
+      &&
+      call_traits<
+        typename call_traits<T, void(P0)>::result_type,
+        void(P1)
+      >::is_noexcept
+    ));
+
+  typedef typename decay<
+    typename call_traits<
+      typename call_traits<T, void(P0)>::result_type,
+      void(P1)
+    >::result_type
+  >::type result_type;
+};
+
+template <typename T, typename P0, typename P1, typename ASIO_ELLIPSIS PN>
+struct call_traits<T, void(P0, P1, PN ASIO_ELLIPSIS),
+  typename enable_if<
+    call_traits<T, void(P0)>::overload != ill_formed
+    &&
+    call_traits<
+      typename call_traits<T, void(P0)>::result_type,
+      void(P1, PN ASIO_ELLIPSIS)
+    >::overload != ill_formed
+  >::type>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = n_props);
+
+  ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
+    (
+      call_traits<T, void(P0)>::is_noexcept
+      &&
+      call_traits<
+        typename call_traits<T, void(P0)>::result_type,
+        void(P1, PN ASIO_ELLIPSIS)
+      >::is_noexcept
+    ));
+
+  typedef typename decay<
+    typename call_traits<
+      typename call_traits<T, void(P0)>::result_type,
+      void(P1, PN ASIO_ELLIPSIS)
+    >::result_type
+  >::type result_type;
+};
+
+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_require_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(
+        ASIO_MOVE_CAST(Property)(p));
+  }
+
+  template <typename T, typename Property>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(Property)>::overload == call_require_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(
+        ASIO_MOVE_CAST(T)(t),
+        ASIO_MOVE_CAST(Property)(p));
+  }
+
+  template <typename T, typename Property>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(Property)>::overload == call_prefer_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).prefer(
+        ASIO_MOVE_CAST(Property)(p));
+  }
+
+  template <typename T, typename Property>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(Property)>::overload == call_prefer_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 prefer(
+        ASIO_MOVE_CAST(T)(t),
+        ASIO_MOVE_CAST(Property)(p));
+  }
+
+  template <typename T, typename P0, typename P1>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(P0, P1)>::overload == two_props,
+    typename call_traits<T, void(P0, P1)>::result_type
+  >::type
+  operator()(
+      ASIO_MOVE_ARG(T) t,
+      ASIO_MOVE_ARG(P0) p0,
+      ASIO_MOVE_ARG(P1) p1) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<T, void(P0, P1)>::is_noexcept))
+  {
+    return (*this)(
+        (*this)(
+          ASIO_MOVE_CAST(T)(t),
+          ASIO_MOVE_CAST(P0)(p0)),
+        ASIO_MOVE_CAST(P1)(p1));
+  }
+
+  template <typename T, typename P0, typename P1,
+    typename ASIO_ELLIPSIS PN>
+  ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if<
+    call_traits<T, void(P0, P1, PN ASIO_ELLIPSIS)>::overload == n_props,
+    typename call_traits<T, void(P0, P1, PN ASIO_ELLIPSIS)>::result_type
+  >::type
+  operator()(
+      ASIO_MOVE_ARG(T) t,
+      ASIO_MOVE_ARG(P0) p0,
+      ASIO_MOVE_ARG(P1) p1,
+      ASIO_MOVE_ARG(PN) ASIO_ELLIPSIS pn) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<T, void(P0, P1, PN ASIO_ELLIPSIS)>::is_noexcept))
+  {
+    return (*this)(
+        (*this)(
+          ASIO_MOVE_CAST(T)(t),
+          ASIO_MOVE_CAST(P0)(p0)),
+        ASIO_MOVE_CAST(P1)(p1),
+        ASIO_MOVE_CAST(PN)(pn) ASIO_ELLIPSIS);
+  }
+};
+
+template <typename T = impl>
+struct static_instance
+{
+  static const T instance;
+};
+
+template <typename T>
+const T static_instance<T>::instance = {};
+
+} // namespace asio_prefer_fn
+namespace asio {
+namespace {
+
+static ASIO_CONSTEXPR const asio_prefer_fn::impl&
+  prefer = asio_prefer_fn::static_instance<>::instance;
+
+} // namespace
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Properties>
+struct can_prefer :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(Properties...)>::overload
+      != asio_prefer_fn::ill_formed>
+{
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename P0 = void,
+    typename P1 = void, typename P2 = void>
+struct can_prefer :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(P0, P1, P2)>::overload
+      != asio_prefer_fn::ill_formed>
+{
+};
+
+template <typename T, typename P0, typename P1>
+struct can_prefer<T, P0, P1> :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(P0, P1)>::overload
+      != asio_prefer_fn::ill_formed>
+{
+};
+
+template <typename T, typename P0>
+struct can_prefer<T, P0> :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(P0)>::overload
+      != asio_prefer_fn::ill_formed>
+{
+};
+
+template <typename T>
+struct can_prefer<T> :
+  false_type
+{
+};
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename ASIO_ELLIPSIS Properties>
+constexpr bool can_prefer_v
+  = can_prefer<T, Properties ASIO_ELLIPSIS>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Properties>
+struct is_nothrow_prefer :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(Properties...)>::is_noexcept>
+{
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename P0 = void,
+    typename P1 = void, typename P2 = void>
+struct is_nothrow_prefer :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(P0, P1, P2)>::is_noexcept>
+{
+};
+
+template <typename T, typename P0, typename P1>
+struct is_nothrow_prefer<T, P0, P1> :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(P0, P1)>::is_noexcept>
+{
+};
+
+template <typename T, typename P0>
+struct is_nothrow_prefer<T, P0> :
+  integral_constant<bool,
+    asio_prefer_fn::call_traits<T, void(P0)>::is_noexcept>
+{
+};
+
+template <typename T>
+struct is_nothrow_prefer<T> :
+  false_type
+{
+};
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename ASIO_ELLIPSIS Properties>
+constexpr bool is_nothrow_prefer_v
+  = is_nothrow_prefer<T, Properties ASIO_ELLIPSIS>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Properties>
+struct prefer_result
+{
+  typedef typename asio_prefer_fn::call_traits<
+      T, void(Properties...)>::result_type type;
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename P0 = void,
+    typename P1 = void, typename P2 = void>
+struct prefer_result
+{
+  typedef typename asio_prefer_fn::call_traits<
+      T, void(P0, P1, P2)>::result_type type;
+};
+
+template <typename T, typename P0, typename P1>
+struct prefer_result<T, P0, P1>
+{
+  typedef typename asio_prefer_fn::call_traits<
+      T, void(P0, P1)>::result_type type;
+};
+
+template <typename T, typename P0>
+struct prefer_result<T, P0>
+{
+  typedef typename asio_prefer_fn::call_traits<
+      T, void(P0)>::result_type type;
+};
+
+template <typename T>
+struct prefer_result<T>
+{
+};
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+} // namespace asio
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_PREFER_HPP