couchbase 3.5.0 → 3.5.1

data/ext/cache/asio/41f31469d0dd420500b334dc8c2fd3ffe7320d8e/asio/asio/include/asio/error.hpp

@@ -0,0 +1,389 @@
+//
+// error.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2023 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_ERROR_HPP
+#define ASIO_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/error_code.hpp"
+#include "asio/system_error.hpp"
+#if defined(ASIO_WINDOWS) \
+  || defined(__CYGWIN__) \
+  || defined(ASIO_WINDOWS_RUNTIME)
+# include <winerror.h>
+#else
+# include <cerrno>
+# include <netdb.h>
+#endif
+
+#if defined(GENERATING_DOCUMENTATION)
+/// INTERNAL ONLY.
+# define ASIO_NATIVE_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define ASIO_SOCKET_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define ASIO_NETDB_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define ASIO_GETADDRINFO_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined
+#elif defined(ASIO_WINDOWS_RUNTIME)
+# define ASIO_NATIVE_ERROR(e) __HRESULT_FROM_WIN32(e)
+# define ASIO_SOCKET_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
+# define ASIO_NETDB_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
+# define ASIO_GETADDRINFO_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
+# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+# define ASIO_NATIVE_ERROR(e) e
+# define ASIO_SOCKET_ERROR(e) WSA ## e
+# define ASIO_NETDB_ERROR(e) WSA ## e
+# define ASIO_GETADDRINFO_ERROR(e) WSA ## e
+# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
+#else
+# define ASIO_NATIVE_ERROR(e) e
+# define ASIO_SOCKET_ERROR(e) e
+# define ASIO_NETDB_ERROR(e) e
+# define ASIO_GETADDRINFO_ERROR(e) e
+# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_posix
+#endif
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace error {
+
+enum basic_errors
+{
+  /// Permission denied.
+  access_denied = ASIO_SOCKET_ERROR(EACCES),
+
+  /// Address family not supported by protocol.
+  address_family_not_supported = ASIO_SOCKET_ERROR(EAFNOSUPPORT),
+
+  /// Address already in use.
+  address_in_use = ASIO_SOCKET_ERROR(EADDRINUSE),
+
+  /// Transport endpoint is already connected.
+  already_connected = ASIO_SOCKET_ERROR(EISCONN),
+
+  /// Operation already in progress.
+  already_started = ASIO_SOCKET_ERROR(EALREADY),
+
+  /// Broken pipe.
+  broken_pipe = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(ERROR_BROKEN_PIPE),
+      ASIO_NATIVE_ERROR(EPIPE)),
+
+  /// A connection has been aborted.
+  connection_aborted = ASIO_SOCKET_ERROR(ECONNABORTED),
+
+  /// Connection refused.
+  connection_refused = ASIO_SOCKET_ERROR(ECONNREFUSED),
+
+  /// Connection reset by peer.
+  connection_reset = ASIO_SOCKET_ERROR(ECONNRESET),
+
+  /// Bad file descriptor.
+  bad_descriptor = ASIO_SOCKET_ERROR(EBADF),
+
+  /// Bad address.
+  fault = ASIO_SOCKET_ERROR(EFAULT),
+
+  /// No route to host.
+  host_unreachable = ASIO_SOCKET_ERROR(EHOSTUNREACH),
+
+  /// Operation now in progress.
+  in_progress = ASIO_SOCKET_ERROR(EINPROGRESS),
+
+  /// Interrupted system call.
+  interrupted = ASIO_SOCKET_ERROR(EINTR),
+
+  /// Invalid argument.
+  invalid_argument = ASIO_SOCKET_ERROR(EINVAL),
+
+  /// Message too long.
+  message_size = ASIO_SOCKET_ERROR(EMSGSIZE),
+
+  /// The name was too long.
+  name_too_long = ASIO_SOCKET_ERROR(ENAMETOOLONG),
+
+  /// Network is down.
+  network_down = ASIO_SOCKET_ERROR(ENETDOWN),
+
+  /// Network dropped connection on reset.
+  network_reset = ASIO_SOCKET_ERROR(ENETRESET),
+
+  /// Network is unreachable.
+  network_unreachable = ASIO_SOCKET_ERROR(ENETUNREACH),
+
+  /// Too many open files.
+  no_descriptors = ASIO_SOCKET_ERROR(EMFILE),
+
+  /// No buffer space available.
+  no_buffer_space = ASIO_SOCKET_ERROR(ENOBUFS),
+
+  /// Cannot allocate memory.
+  no_memory = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(ERROR_OUTOFMEMORY),
+      ASIO_NATIVE_ERROR(ENOMEM)),
+
+  /// Operation not permitted.
+  no_permission = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(ERROR_ACCESS_DENIED),
+      ASIO_NATIVE_ERROR(EPERM)),
+
+  /// Protocol not available.
+  no_protocol_option = ASIO_SOCKET_ERROR(ENOPROTOOPT),
+
+  /// No such device.
+  no_such_device = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(ERROR_BAD_UNIT),
+      ASIO_NATIVE_ERROR(ENODEV)),
+
+  /// Transport endpoint is not connected.
+  not_connected = ASIO_SOCKET_ERROR(ENOTCONN),
+
+  /// Socket operation on non-socket.
+  not_socket = ASIO_SOCKET_ERROR(ENOTSOCK),
+
+  /// Operation cancelled.
+  operation_aborted = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(ERROR_OPERATION_ABORTED),
+      ASIO_NATIVE_ERROR(ECANCELED)),
+
+  /// Operation not supported.
+  operation_not_supported = ASIO_SOCKET_ERROR(EOPNOTSUPP),
+
+  /// Cannot send after transport endpoint shutdown.
+  shut_down = ASIO_SOCKET_ERROR(ESHUTDOWN),
+
+  /// Connection timed out.
+  timed_out = ASIO_SOCKET_ERROR(ETIMEDOUT),
+
+  /// Resource temporarily unavailable.
+  try_again = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(ERROR_RETRY),
+      ASIO_NATIVE_ERROR(EAGAIN)),
+
+  /// The socket is marked non-blocking and the requested operation would block.
+  would_block = ASIO_SOCKET_ERROR(EWOULDBLOCK)
+};
+
+enum netdb_errors
+{
+  /// Host not found (authoritative).
+  host_not_found = ASIO_NETDB_ERROR(HOST_NOT_FOUND),
+
+  /// Host not found (non-authoritative).
+  host_not_found_try_again = ASIO_NETDB_ERROR(TRY_AGAIN),
+
+  /// The query is valid but does not have associated address data.
+  no_data = ASIO_NETDB_ERROR(NO_DATA),
+
+  /// A non-recoverable error occurred.
+  no_recovery = ASIO_NETDB_ERROR(NO_RECOVERY)
+};
+
+enum addrinfo_errors
+{
+  /// The service is not supported for the given socket type.
+  service_not_found = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND),
+      ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),
+
+  /// The socket type is not supported.
+  socket_type_not_supported = ASIO_WIN_OR_POSIX(
+      ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT),
+      ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE))
+};
+
+enum misc_errors
+{
+  /// Already open.
+  already_open = 1,
+
+  /// End of file or stream.
+  eof,
+
+  /// Element not found.
+  not_found,
+
+  /// The descriptor cannot fit into the select system call's fd_set.
+  fd_set_failure
+};
+
+// boostify: non-boost code starts here
+#if !defined(ASIO_ERROR_LOCATION)
+# define ASIO_ERROR_LOCATION(e) (void)0
+#endif // !defined(ASIO_ERROR_LOCATION)
+
+// boostify: non-boost code ends here
+#if !defined(ASIO_ERROR_LOCATION) \
+  && !defined(ASIO_DISABLE_ERROR_LOCATION) \
+  && defined(ASIO_HAS_BOOST_CONFIG) \
+  && (BOOST_VERSION >= 107900)
+
+# define ASIO_ERROR_LOCATION(e) \
+  do { \
+    BOOST_STATIC_CONSTEXPR boost::source_location loc \
+      = BOOST_CURRENT_LOCATION; \
+    (e).assign((e), &loc); \
+  } while (false)
+
+#else // !defined(ASIO_ERROR_LOCATION)
+      //   && !defined(ASIO_DISABLE_ERROR_LOCATION)
+      //   && defined(ASIO_HAS_BOOST_CONFIG)
+      //   && (BOOST_VERSION >= 107900)
+
+# define ASIO_ERROR_LOCATION(e) (void)0
+
+#endif // !defined(ASIO_ERROR_LOCATION)
+       //   && !defined(ASIO_DISABLE_ERROR_LOCATION)
+       //   && defined(ASIO_HAS_BOOST_CONFIG)
+       //   && (BOOST_VERSION >= 107900)
+
+inline void clear(asio::error_code& ec)
+{
+  ec.assign(0, ec.category());
+}
+
+inline const asio::error_category& get_system_category()
+{
+  return asio::system_category();
+}
+
+#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
+
+extern ASIO_DECL
+const asio::error_category& get_netdb_category();
+
+extern ASIO_DECL
+const asio::error_category& get_addrinfo_category();
+
+#else // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
+
+inline const asio::error_category& get_netdb_category()
+{
+  return get_system_category();
+}
+
+inline const asio::error_category& get_addrinfo_category()
+{
+  return get_system_category();
+}
+
+#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
+
+extern ASIO_DECL
+const asio::error_category& get_misc_category();
+
+static const asio::error_category&
+  system_category ASIO_UNUSED_VARIABLE
+  = asio::error::get_system_category();
+static const asio::error_category&
+  netdb_category ASIO_UNUSED_VARIABLE
+  = asio::error::get_netdb_category();
+static const asio::error_category&
+  addrinfo_category ASIO_UNUSED_VARIABLE
+  = asio::error::get_addrinfo_category();
+static const asio::error_category&
+  misc_category ASIO_UNUSED_VARIABLE
+  = asio::error::get_misc_category();
+
+} // namespace error
+} // namespace asio
+
+namespace std {
+
+template<> struct is_error_code_enum<asio::error::basic_errors>
+{
+  static const bool value = true;
+};
+
+template<> struct is_error_code_enum<asio::error::netdb_errors>
+{
+  static const bool value = true;
+};
+
+template<> struct is_error_code_enum<asio::error::addrinfo_errors>
+{
+  static const bool value = true;
+};
+
+template<> struct is_error_code_enum<asio::error::misc_errors>
+{
+  static const bool value = true;
+};
+
+} // namespace std
+
+namespace asio {
+namespace error {
+
+inline asio::error_code make_error_code(basic_errors e)
+{
+  return asio::error_code(
+      static_cast<int>(e), get_system_category());
+}
+
+inline asio::error_code make_error_code(netdb_errors e)
+{
+  return asio::error_code(
+      static_cast<int>(e), get_netdb_category());
+}
+
+inline asio::error_code make_error_code(addrinfo_errors e)
+{
+  return asio::error_code(
+      static_cast<int>(e), get_addrinfo_category());
+}
+
+inline asio::error_code make_error_code(misc_errors e)
+{
+  return asio::error_code(
+      static_cast<int>(e), get_misc_category());
+}
+
+} // namespace error
+namespace stream_errc {
+  // Simulates the proposed stream_errc scoped enum.
+  using error::eof;
+  using error::not_found;
+} // namespace stream_errc
+namespace socket_errc {
+  // Simulates the proposed socket_errc scoped enum.
+  using error::already_open;
+  using error::not_found;
+} // namespace socket_errc
+namespace resolver_errc {
+  // Simulates the proposed resolver_errc scoped enum.
+  using error::host_not_found;
+  const error::netdb_errors try_again = error::host_not_found_try_again;
+  using error::service_not_found;
+} // namespace resolver_errc
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#undef ASIO_NATIVE_ERROR
+#undef ASIO_SOCKET_ERROR
+#undef ASIO_NETDB_ERROR
+#undef ASIO_GETADDRINFO_ERROR
+#undef ASIO_WIN_OR_POSIX
+
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/error.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_ERROR_HPP

data/ext/cache/asio/41f31469d0dd420500b334dc8c2fd3ffe7320d8e/asio/asio/include/asio/error_code.hpp

@@ -0,0 +1,39 @@
+//
+// error_code.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 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_ERROR_CODE_HPP
+#define ASIO_ERROR_CODE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <system_error>
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+typedef std::error_category error_category;
+typedef std::error_code error_code;
+
+/// Returns the error category used for the system errors produced by asio.
+extern ASIO_DECL const error_category& system_category();
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/error_code.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // ASIO_ERROR_CODE_HPP

data/ext/cache/asio/41f31469d0dd420500b334dc8c2fd3ffe7320d8e/asio/asio/include/asio/execution/allocator.hpp

@@ -0,0 +1,278 @@
+//
+// execution/allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2023 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_ALLOCATOR_HPP
+#define ASIO_EXECUTION_ALLOCATOR_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/is_applicable_property.hpp"
+#include "asio/traits/query_static_constexpr_member.hpp"
+#include "asio/traits/static_query.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace execution {
+
+/// A property to describe which allocator an executor will use to allocate the
+/// memory required to store a submitted function object.
+template <typename ProtoAllocator>
+struct allocator_t
+{
+  /// The allocator_t property applies to executors.
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+  /// The allocator_t property can be required.
+  static constexpr bool is_requirable = true;
+
+  /// The allocator_t property can be preferred.
+  static constexpr bool is_preferable = true;
+
+  /// Default constructor.
+  constexpr allocator_t();
+
+  /// Obtain the allocator stored in the allocator_t property object.
+  /**
+   * Present only if @c ProtoAllocator is non-void.
+   */
+  constexpr ProtoAllocator value() const;
+
+  /// Create an allocator_t object with a different allocator.
+  /**
+   * Present only if @c ProtoAllocator is void.
+   */
+  template <typename OtherAllocator>
+  allocator_t<OtherAllocator operator()(const OtherAllocator& a);
+};
+
+/// A special value used for accessing the allocator_t property.
+constexpr allocator_t<void> allocator;
+
+} // namespace execution
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace execution {
+
+template <typename ProtoAllocator>
+struct allocator_t
+{
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor<T>::value;
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+  static constexpr bool is_requirable = true;
+  static constexpr bool is_preferable = true;
+
+  template <typename T>
+  struct static_proxy
+  {
+#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+    struct type
+    {
+      template <typename P>
+      static constexpr auto query(P&& p)
+        noexcept(
+          noexcept(
+            conditional_t<true, T, P>::query(static_cast<P&&>(p))
+          )
+        )
+        -> decltype(
+          conditional_t<true, T, P>::query(static_cast<P&&>(p))
+        )
+      {
+        return T::query(static_cast<P&&>(p));
+      }
+    };
+#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+    typedef T type;
+#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+  };
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename static_proxy<T>::type, allocator_t> {};
+
+#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+  template <typename T>
+  static constexpr typename query_static_constexpr_member<T>::result_type
+  static_query()
+    noexcept(query_static_constexpr_member<T>::is_noexcept)
+  {
+    return query_static_constexpr_member<T>::value();
+  }
+
+  template <typename E, typename T = decltype(allocator_t::static_query<E>())>
+  static constexpr const T static_query_v = allocator_t::static_query<E>();
+#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+  constexpr ProtoAllocator value() const
+  {
+    return a_;
+  }
+
+private:
+  friend struct allocator_t<void>;
+
+  explicit constexpr allocator_t(const ProtoAllocator& a)
+    : a_(a)
+  {
+  }
+
+  ProtoAllocator a_;
+};
+
+#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+template <typename ProtoAllocator> template <typename E, typename T>
+const T allocator_t<ProtoAllocator>::static_query_v;
+#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+template <>
+struct allocator_t<void>
+{
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor<T>::value;
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+  static constexpr bool is_requirable = true;
+  static constexpr bool is_preferable = true;
+
+  constexpr allocator_t()
+  {
+  }
+
+  template <typename T>
+  struct static_proxy
+  {
+#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+    struct type
+    {
+      template <typename P>
+      static constexpr auto query(P&& p)
+        noexcept(
+          noexcept(
+            conditional_t<true, T, P>::query(static_cast<P&&>(p))
+          )
+        )
+        -> decltype(
+          conditional_t<true, T, P>::query(static_cast<P&&>(p))
+        )
+      {
+        return T::query(static_cast<P&&>(p));
+      }
+    };
+#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+    typedef T type;
+#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+  };
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename static_proxy<T>::type, allocator_t> {};
+
+#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+  template <typename T>
+  static constexpr typename query_static_constexpr_member<T>::result_type
+  static_query()
+    noexcept(query_static_constexpr_member<T>::is_noexcept)
+  {
+    return query_static_constexpr_member<T>::value();
+  }
+
+  template <typename E, typename T = decltype(allocator_t::static_query<E>())>
+  static constexpr const T static_query_v = allocator_t::static_query<E>();
+#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+  template <typename OtherProtoAllocator>
+  constexpr allocator_t<OtherProtoAllocator> operator()(
+      const OtherProtoAllocator& a) const
+  {
+    return allocator_t<OtherProtoAllocator>(a);
+  }
+};
+
+#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+template <typename E, typename T>
+const T allocator_t<void>::static_query_v;
+#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+constexpr allocator_t<void> allocator;
+
+} // namespace execution
+
+#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename T, typename ProtoAllocator>
+struct is_applicable_property<T, execution::allocator_t<ProtoAllocator>>
+  : integral_constant<bool, execution::is_executor<T>::value>
+{
+};
+
+#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+namespace traits {
+
+#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
+  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+template <typename T, typename ProtoAllocator>
+struct static_query<T, execution::allocator_t<ProtoAllocator>,
+  enable_if_t<
+    execution::allocator_t<ProtoAllocator>::template
+      query_static_constexpr_member<T>::is_valid
+  >>
+{
+  static constexpr bool is_valid = true;
+  static constexpr bool is_noexcept = true;
+
+  typedef typename execution::allocator_t<ProtoAllocator>::template
+    query_static_constexpr_member<T>::result_type result_type;
+
+  static constexpr result_type value()
+  {
+    return execution::allocator_t<ProtoAllocator>::template
+      query_static_constexpr_member<T>::value();
+  }
+};
+
+#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
+       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
+
+} // namespace traits
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTION_ALLOCATOR_HPP