couchbase 3.0.0 → 3.0.1

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

@@ -0,0 +1,296 @@
+//
+// query.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_QUERY_HPP
+#define ASIO_QUERY_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/query_member.hpp"
+#include "asio/traits/query_free.hpp"
+#include "asio/traits/static_query.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace asio {
+
+/// A customisation point that queries the value of a property.
+/**
+ * The name <tt>query</tt> denotes a customization point object. The
+ * expression <tt>asio::query(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></tt> is not a well-formed
+ *   constant expression with value <tt>true</tt>, <tt>asio::query(E,
+ *   P)</tt> is ill-formed.
+ *
+ * @li Otherwise, <tt>Prop::template static_query_v<T></tt> if the expression
+ *   <tt>Prop::template static_query_v<T></tt> is a well-formed constant
+ *   expression.
+ *
+ * @li Otherwise, <tt>(E).query(P)</tt> if the expression
+ *   <tt>(E).query(P)</tt> is well-formed.
+ *
+ * @li Otherwise, <tt>query(E, P)</tt> if the expression
+ *   <tt>query(E, P)</tt> is a valid expression with overload
+ *   resolution performed in a context that does not include the declaration
+ *   of the <tt>query</tt> customization point object.
+ *
+ * @li Otherwise, <tt>asio::query(E, P)</tt> is ill-formed.
+ */
+inline constexpr unspecified query = unspecified;
+
+/// A type trait that determines whether a @c query expression is well-formed.
+/**
+ * Class template @c can_query is a trait that is derived from
+ * @c true_type if the expression <tt>asio::query(std::declval<T>(),
+ * std::declval<Property>())</tt> is well formed; otherwise @c false_type.
+ */
+template <typename T, typename Property>
+struct can_query :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines whether a @c query expression will
+/// not throw.
+/**
+ * Class template @c is_nothrow_query is a trait that is derived from
+ * @c true_type if the expression <tt>asio::query(std::declval<T>(),
+ * std::declval<Property>())</tt> is @c noexcept; otherwise @c false_type.
+ */
+template <typename T, typename Property>
+struct is_nothrow_query :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines the result type of a @c query expression.
+/**
+ * Class template @c query_result is a trait that determines the result
+ * type of the expression <tt>asio::query(std::declval<T>(),
+ * std::declval<Property>())</tt>.
+ */
+template <typename T, typename Property>
+struct query_result
+{
+  /// The result of the @c query expression.
+  typedef automatically_determined type;
+};
+
+} // namespace asio
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace asio_query_fn {
+
+using asio::decay;
+using asio::declval;
+using asio::enable_if;
+using asio::is_applicable_property;
+using asio::traits::query_free;
+using asio::traits::query_member;
+using asio::traits::static_query;
+
+void query();
+
+enum overload_type
+{
+  static_value,
+  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
+      &&
+      static_query<T, Property>::is_valid
+    )
+  >::type> :
+  static_query<T, Property>
+{
+  ASIO_STATIC_CONSTEXPR(overload_type, overload = static_value);
+};
+
+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
+      &&
+      !static_query<T, Property>::is_valid
+      &&
+      query_member<T, Property>::is_valid
+    )
+  >::type> :
+  query_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
+      &&
+      !static_query<T, Property>::is_valid
+      &&
+      !query_member<T, Property>::is_valid
+      &&
+      query_free<T, Property>::is_valid
+    )
+  >::type> :
+  query_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 == static_value,
+    typename call_traits<T, void(Property)>::result_type
+  >::type
+  operator()(
+      ASIO_MOVE_ARG(T),
+      ASIO_MOVE_ARG(Property)) const
+    ASIO_NOEXCEPT_IF((
+      call_traits<T, void(Property)>::is_noexcept))
+  {
+    return static_query<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value();
+  }
+
+  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).query(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 query(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_query_fn
+namespace asio {
+namespace {
+
+static ASIO_CONSTEXPR const asio_query_fn::impl&
+  query = asio_query_fn::static_instance<>::instance;
+
+} // namespace
+
+template <typename T, typename Property>
+struct can_query :
+  integral_constant<bool,
+    asio_query_fn::call_traits<T, void(Property)>::overload !=
+      asio_query_fn::ill_formed>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+constexpr bool can_query_v
+  = can_query<T, Property>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+struct is_nothrow_query :
+  integral_constant<bool,
+    asio_query_fn::call_traits<T, void(Property)>::is_noexcept>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+constexpr bool is_nothrow_query_v
+  = is_nothrow_query<T, Property>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename Property>
+struct query_result
+{
+  typedef typename asio_query_fn::call_traits<
+      T, void(Property)>::result_type type;
+};
+
+} // namespace asio
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_QUERY_HPP

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

@@ -114,7 +114,7 @@ struct is_match_condition
  * @par Example
  * To read data into a @c std::string until a newline is encountered:
  * @code std::string data;
- * std::string n = asio::read_until(s,
+ * std::size_t n = asio::read_until(s,
  *     asio::dynamic_buffer(data), '\n');
  * std::string line = data.substr(0, n);
  * data.erase(0, n); @endcode
@@ -216,7 +216,7 @@ std::size_t read_until(SyncReadStream& s,
  * @par Example
  * To read data into a @c std::string until a CR-LF sequence is encountered:
  * @code std::string data;
- * std::string n = asio::read_until(s,
+ * std::size_t n = asio::read_until(s,
  *     asio::dynamic_buffer(data), "\r\n");
  * std::string line = data.substr(0, n);
  * data.erase(0, n); @endcode
@@ -327,7 +327,7 @@ std::size_t read_until(SyncReadStream& s,
  * @par Example
  * To read data into a @c std::string until a CR-LF sequence is encountered:
  * @code std::string data;
- * std::string n = asio::read_until(s,
+ * std::size_t n = asio::read_until(s,
  *     asio::dynamic_buffer(data), boost::regex("\r\n"));
  * std::string line = data.substr(0, n);
  * data.erase(0, n); @endcode
@@ -1055,7 +1055,7 @@ std::size_t read_until(SyncReadStream& s,
  * @par Example
  * To read data into a @c std::string until a newline is encountered:
  * @code std::string data;
- * std::string n = asio::read_until(s,
+ * std::size_t n = asio::read_until(s,
  *     asio::dynamic_buffer(data), '\n');
  * std::string line = data.substr(0, n);
  * data.erase(0, n); @endcode
@@ -1153,7 +1153,7 @@ std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
  * @par Example
  * To read data into a @c std::string until a CR-LF sequence is encountered:
  * @code std::string data;
- * std::string n = asio::read_until(s,
+ * std::size_t n = asio::read_until(s,
  *     asio::dynamic_buffer(data), "\r\n");
  * std::string line = data.substr(0, n);
  * data.erase(0, n); @endcode
@@ -1259,7 +1259,7 @@ std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
  * @par Example
  * To read data into a @c std::string until a CR-LF sequence is encountered:
  * @code std::string data;
- * std::string n = asio::read_until(s,
+ * std::size_t n = asio::read_until(s,
  *     asio::dynamic_buffer(data), boost::regex("\r\n"));
  * std::string line = data.substr(0, n);
  * data.erase(0, n); @endcode

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

@@ -0,0 +1,524 @@
+//
+// require.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_HPP
+#define ASIO_REQUIRE_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_member.hpp"
+#include "asio/traits/require_free.hpp"
+#include "asio/traits/static_require.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace asio {
+
+/// A customisation point that applies a concept-preserving property to an
+/// object.
+/**
+ * The name <tt>require</tt> denotes a customisation point object. The
+ * expression <tt>asio::require(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_requirable</tt> is
+ *   not a well-formed constant expression with value <tt>true</tt>,
+ *   <tt>asio::require(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>asio::require(asio::require(E, P0), Pn...)</tt>
+ *   if <tt>N > 0</tt> and the expression
+ *   <tt>asio::require(asio::require(E, P0), Pn...)</tt>
+ *   is a valid expression.
+ *
+ * @li Otherwise, <tt>asio::require(E, P0, Pn...)</tt> is ill-formed.
+ */
+inline constexpr unspecified require = unspecified;
+
+/// A type trait that determines whether a @c require expression is well-formed.
+/**
+ * Class template @c can_require is a trait that is derived from
+ * @c true_type if the expression <tt>asio::require(std::declval<T>(),
+ * std::declval<Properties>()...)</tt> is well formed; otherwise @c false_type.
+ */
+template <typename T, typename... Properties>
+struct can_require :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines whether a @c require expression will not throw.
+/**
+ * Class template @c is_nothrow_require is a trait that is derived from
+ * @c true_type if the expression <tt>asio::require(std::declval<T>(),
+ * std::declval<Properties>()...)</tt> is @c noexcept; otherwise @c false_type.
+ */
+template <typename T, typename... Properties>
+struct is_nothrow_require :
+  integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait that determines the result type of a @c require expression.
+/**
+ * Class template @c require_result is a trait that determines the result
+ * type of the expression <tt>asio::require(std::declval<T>(),
+ * std::declval<Properties>()...)</tt>.
+ */
+template <typename T, typename... Properties>
+struct require_result
+{
+  /// The result of the @c require expression.
+  typedef automatically_determined type;
+};
+
+} // namespace asio
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace asio_require_fn {
+
+using asio::decay;
+using asio::declval;
+using asio::enable_if;
+using asio::is_applicable_property;
+using asio::traits::require_free;
+using asio::traits::require_member;
+using asio::traits::static_require;
+
+void require();
+
+enum overload_type
+{
+  identity,
+  call_member,
+  call_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_requirable
+      &&
+      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_requirable
+      &&
+      !static_require<T, Property>::is_valid
+      &&
+      require_member<T, Property>::is_valid
+    )
+  >::type> :
+  require_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
+      &&
+      !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_free);
+};
+
+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_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_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 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_require_fn
+namespace asio {
+namespace {
+
+static ASIO_CONSTEXPR const asio_require_fn::impl&
+  require = asio_require_fn::static_instance<>::instance;
+
+} // namespace
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Properties>
+struct can_require :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(Properties...)>::overload
+      != asio_require_fn::ill_formed>
+{
+};
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename P0 = void,
+    typename P1 = void, typename P2 = void>
+struct can_require :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(P0, P1, P2)>::overload
+      != asio_require_fn::ill_formed>
+{
+};
+
+template <typename T, typename P0, typename P1>
+struct can_require<T, P0, P1> :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(P0, P1)>::overload
+      != asio_require_fn::ill_formed>
+{
+};
+
+template <typename T, typename P0>
+struct can_require<T, P0> :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(P0)>::overload
+      != asio_require_fn::ill_formed>
+{
+};
+
+template <typename T>
+struct can_require<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_require_v
+  = can_require<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_require :
+  integral_constant<bool,
+    asio_require_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_require :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(P0, P1, P2)>::is_noexcept>
+{
+};
+
+template <typename T, typename P0, typename P1>
+struct is_nothrow_require<T, P0, P1> :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(P0, P1)>::is_noexcept>
+{
+};
+
+template <typename T, typename P0>
+struct is_nothrow_require<T, P0> :
+  integral_constant<bool,
+    asio_require_fn::call_traits<T, void(P0)>::is_noexcept>
+{
+};
+
+template <typename T>
+struct is_nothrow_require<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_require_v
+  = is_nothrow_require<T, Properties ASIO_ELLIPSIS>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Properties>
+struct require_result
+{
+  typedef typename asio_require_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 require_result
+{
+  typedef typename asio_require_fn::call_traits<
+      T, void(P0, P1, P2)>::result_type type;
+};
+
+template <typename T, typename P0, typename P1>
+struct require_result<T, P0, P1>
+{
+  typedef typename asio_require_fn::call_traits<
+      T, void(P0, P1)>::result_type type;
+};
+
+template <typename T, typename P0>
+struct require_result<T, P0>
+{
+  typedef typename asio_require_fn::call_traits<
+      T, void(P0)>::result_type type;
+};
+
+template <typename T>
+struct require_result<T>
+{
+};
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+} // namespace asio
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_REQUIRE_HPP