passenger 6.0.23 → 6.0.24

data/src/cxx_supportlib/vendor-modified/boost/asio/connect.hpp

@@ -32,34 +32,97 @@ namespace detail
   template <typename, typename> class initiate_async_range_connect;
   template <typename, typename> class initiate_async_iterator_connect;
 
-  char (&has_iterator_helper(...))[2];
+  template <typename T, typename = void, typename = void>
+  struct is_endpoint_sequence_helper : false_type
+  {
+  };
 
   template <typename T>
-  char has_iterator_helper(T*, typename T::iterator* = 0);
+  struct is_endpoint_sequence_helper<T,
+      void_t<
+        decltype(declval<T>().begin())
+      >,
+      void_t<
+        decltype(declval<T>().end())
+      >
+    > : true_type
+  {
+  };
 
-  template <typename T>
-  struct has_iterator_typedef
+  template <typename T, typename Iterator, typename = void>
+  struct is_connect_condition_helper : false_type
+  {
+  };
+
+  template <typename T, typename Iterator>
+  struct is_connect_condition_helper<T, Iterator,
+      enable_if_t<
+        is_same<
+          result_of_t<T(boost::system::error_code, Iterator)>,
+          Iterator
+        >::value
+      >
+    > : true_type
+  {
+  };
+
+  template <typename T, typename Iterator>
+  struct is_connect_condition_helper<T, Iterator,
+      enable_if_t<
+        is_same<
+          result_of_t<T(boost::system::error_code,
+            decltype(*declval<Iterator>()))>,
+          bool
+        >::value
+      >
+    > : true_type
   {
-    enum { value = (sizeof((has_iterator_helper)((T*)(0))) == 1) };
+  };
+
+  struct default_connect_condition
+  {
+    template <typename Endpoint>
+    bool operator()(const boost::system::error_code&, const Endpoint&)
+    {
+      return true;
+    }
   };
 } // namespace detail
 
+#if defined(GENERATING_DOCUMENTATION)
+
 /// Type trait used to determine whether a type is an endpoint sequence that can
 /// be used with with @c connect and @c async_connect.
 template <typename T>
 struct is_endpoint_sequence
 {
-#if defined(GENERATING_DOCUMENTATION)
   /// The value member is true if the type may be used as an endpoint sequence.
-  static const bool value;
-#else
-  enum
-  {
-    value = detail::has_iterator_typedef<T>::value
-  };
-#endif
+  static const bool value = automatically_determined;
+};
+
+/// Trait for determining whether a function object is a connect condition that
+/// can be used with @c connect and @c async_connect.
+template <typename T, typename Iterator>
+struct is_connect_condition
+{
+  /// The value member is true if the type may be used as a connect condition.
+  static constexpr bool value = automatically_determined;
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename T>
+struct is_endpoint_sequence : detail::is_endpoint_sequence_helper<T>
+{
+};
+
+template <typename T, typename Iterator>
+struct is_connect_condition : detail::is_connect_condition_helper<T, Iterator>
+{
 };
 
+#endif // defined(GENERATING_DOCUMENTATION)
+
 /**
  * @defgroup connect boost::asio::connect
  *
@@ -95,7 +158,9 @@ struct is_endpoint_sequence
 template <typename Protocol, typename Executor, typename EndpointSequence>
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
-    constraint_t<is_endpoint_sequence<EndpointSequence>::value> = 0);
+    constraint_t<
+      is_endpoint_sequence<EndpointSequence>::value
+    > = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -130,7 +195,9 @@ typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
 template <typename Protocol, typename Executor, typename EndpointSequence>
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, boost::system::error_code& ec,
-    constraint_t<is_endpoint_sequence<EndpointSequence>::value> = 0);
+    constraint_t<
+      is_endpoint_sequence<EndpointSequence>::value
+    > = 0);
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
@@ -159,7 +226,9 @@ typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
  */
 template <typename Protocol, typename Executor, typename Iterator>
 Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    constraint_t<!is_endpoint_sequence<Iterator>::value> = 0);
+    constraint_t<
+      !is_endpoint_sequence<Iterator>::value
+    > = 0);
 
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
 /// each endpoint in a sequence.
@@ -188,7 +257,9 @@ Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
 template <typename Protocol, typename Executor, typename Iterator>
 Iterator connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, boost::system::error_code& ec,
-    constraint_t<!is_endpoint_sequence<Iterator>::value> = 0);
+    constraint_t<
+      !is_endpoint_sequence<Iterator>::value
+    > = 0);
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -314,7 +385,13 @@ template <typename Protocol, typename Executor,
     typename EndpointSequence, typename ConnectCondition>
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    constraint_t<is_endpoint_sequence<EndpointSequence>::value> = 0);
+    constraint_t<
+      is_endpoint_sequence<EndpointSequence>::value
+    > = 0,
+    constraint_t<
+      is_connect_condition<ConnectCondition,
+        decltype(declval<const EndpointSequence&>().begin())>::value
+    > = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -381,7 +458,13 @@ template <typename Protocol, typename Executor,
 typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
     boost::system::error_code& ec,
-    constraint_t<is_endpoint_sequence<EndpointSequence>::value> = 0);
+    constraint_t<
+      is_endpoint_sequence<EndpointSequence>::value
+    > = 0,
+    constraint_t<
+      is_connect_condition<ConnectCondition,
+        decltype(declval<const EndpointSequence&>().begin())>::value
+    > = 0);
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
@@ -423,7 +506,12 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition>
 Iterator connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, ConnectCondition connect_condition,
-    constraint_t<!is_endpoint_sequence<Iterator>::value> = 0);
+    constraint_t<
+      !is_endpoint_sequence<Iterator>::value
+    > = 0,
+    constraint_t<
+      is_connect_condition<ConnectCondition, Iterator>::value
+    > = 0);
 
 /// (Deprecated: Use range overload.) Establishes a socket connection by trying
 /// each endpoint in a sequence.
@@ -464,7 +552,12 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition>
 Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     ConnectCondition connect_condition, boost::system::error_code& ec,
-    constraint_t<!is_endpoint_sequence<Iterator>::value> = 0);
+    constraint_t<
+      !is_endpoint_sequence<Iterator>::value
+    > = 0,
+    constraint_t<
+      is_connect_condition<ConnectCondition, Iterator>::value
+    > = 0);
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
@@ -524,7 +617,10 @@ Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition>
 Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    Iterator end, ConnectCondition connect_condition);
+    Iterator end, ConnectCondition connect_condition,
+    constraint_t<
+      is_connect_condition<ConnectCondition, Iterator>::value
+    > = 0);
 
 /// Establishes a socket connection by trying each endpoint in a sequence.
 /**
@@ -593,7 +689,10 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition>
 Iterator connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
-    boost::system::error_code& ec);
+    boost::system::error_code& ec,
+    constraint_t<
+      is_connect_condition<ConnectCondition, Iterator>::value
+    > = 0);
 
 /*@}*/
 
@@ -637,7 +736,7 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, typename Protocol::endpoint) @endcode
@@ -686,15 +785,27 @@ template <typename Protocol, typename Executor, typename EndpointSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       typename Protocol::endpoint)) RangeConnectToken
         = default_completion_token_t<Executor>>
-auto async_connect(basic_socket<Protocol, Executor>& s,
+inline auto async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
     RangeConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<is_endpoint_sequence<EndpointSequence>::value> = 0)
+    constraint_t<
+      is_endpoint_sequence<EndpointSequence>::value
+    > = 0,
+    constraint_t<
+      !is_connect_condition<RangeConnectToken,
+        decltype(declval<const EndpointSequence&>().begin())>::value
+    > = 0)
   -> decltype(
     async_initiate<RangeConnectToken,
       void (boost::system::error_code, typename Protocol::endpoint)>(
         declval<detail::initiate_async_range_connect<Protocol, Executor>>(),
-        token, endpoints, declval<detail::default_connect_condition>()));
+        token, endpoints, declval<detail::default_connect_condition>()))
+{
+  return async_initiate<RangeConnectToken,
+    void (boost::system::error_code, typename Protocol::endpoint)>(
+      detail::initiate_async_range_connect<Protocol, Executor>(s),
+      token, endpoints, detail::default_connect_condition());
+}
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Asynchronously establishes a socket
@@ -729,7 +840,7 @@ auto async_connect(basic_socket<Protocol, Executor>& s,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, Iterator) @endcode
@@ -751,15 +862,29 @@ auto async_connect(basic_socket<Protocol, Executor>& s,
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-auto async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
+inline auto async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     IteratorConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<!is_endpoint_sequence<Iterator>::value> = 0)
+    constraint_t<
+      !is_endpoint_sequence<Iterator>::value
+    > = 0,
+    constraint_t<
+      !is_same<Iterator, decay_t<IteratorConnectToken>>::value
+    > = 0,
+    constraint_t<
+      !is_connect_condition<IteratorConnectToken, Iterator>::value
+    > = 0)
   -> decltype(
     async_initiate<IteratorConnectToken,
       void (boost::system::error_code, Iterator)>(
         declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
         token, begin, Iterator(),
-        declval<detail::default_connect_condition>()));
+        declval<detail::default_connect_condition>()))
+{
+  return async_initiate<IteratorConnectToken,
+    void (boost::system::error_code, Iterator)>(
+      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
+      token, begin, Iterator(), detail::default_connect_condition());
+}
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
@@ -796,7 +921,7 @@ auto async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, Iterator) @endcode
@@ -830,14 +955,23 @@ auto async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-auto async_connect(
+inline auto async_connect(
     basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
-    IteratorConnectToken&& token = default_completion_token_t<Executor>())
+    IteratorConnectToken&& token = default_completion_token_t<Executor>(),
+    constraint_t<
+      !is_connect_condition<IteratorConnectToken, Iterator>::value
+    > = 0)
   -> decltype(
     async_initiate<IteratorConnectToken,
       void (boost::system::error_code, Iterator)>(
         declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, end, declval<detail::default_connect_condition>()));
+        token, begin, end, declval<detail::default_connect_condition>()))
+{
+  return async_initiate<IteratorConnectToken,
+    void (boost::system::error_code, Iterator)>(
+      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
+      token, begin, end, detail::default_connect_condition());
+}
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
@@ -882,7 +1016,7 @@ auto async_connect(
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, typename Protocol::endpoint) @endcode
@@ -955,15 +1089,27 @@ template <typename Protocol, typename Executor,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       typename Protocol::endpoint)) RangeConnectToken
         = default_completion_token_t<Executor>>
-auto async_connect(basic_socket<Protocol, Executor>& s,
+inline auto async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
     RangeConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<is_endpoint_sequence<EndpointSequence>::value> = 0)
+    constraint_t<
+      is_endpoint_sequence<EndpointSequence>::value
+    > = 0,
+    constraint_t<
+      is_connect_condition<ConnectCondition,
+        decltype(declval<const EndpointSequence&>().begin())>::value
+    > = 0)
   -> decltype(
     async_initiate<RangeConnectToken,
       void (boost::system::error_code, typename Protocol::endpoint)>(
         declval<detail::initiate_async_range_connect<Protocol, Executor>>(),
-        token, endpoints, connect_condition));
+        token, endpoints, connect_condition))
+{
+  return async_initiate<RangeConnectToken,
+    void (boost::system::error_code, typename Protocol::endpoint)>(
+      detail::initiate_async_range_connect<Protocol, Executor>(s),
+      token, endpoints, connect_condition);
+}
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 /// (Deprecated: Use range overload.) Asynchronously establishes a socket
@@ -1009,7 +1155,7 @@ auto async_connect(basic_socket<Protocol, Executor>& s,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, Iterator) @endcode
@@ -1032,15 +1178,26 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-auto async_connect(basic_socket<Protocol, Executor>& s,
+inline auto async_connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, ConnectCondition connect_condition,
     IteratorConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<!is_endpoint_sequence<Iterator>::value> = 0)
+    constraint_t<
+      !is_endpoint_sequence<Iterator>::value
+    > = 0,
+    constraint_t<
+      is_connect_condition<ConnectCondition, Iterator>::value
+    > = 0)
   -> decltype(
     async_initiate<IteratorConnectToken,
       void (boost::system::error_code, Iterator)>(
         declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, Iterator(), connect_condition));
+        token, begin, Iterator(), connect_condition))
+{
+  return async_initiate<IteratorConnectToken,
+    void (boost::system::error_code, Iterator)>(
+      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
+      token, begin, Iterator(), connect_condition);
+}
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
@@ -1088,7 +1245,7 @@ auto async_connect(basic_socket<Protocol, Executor>& s,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using boost::asio::post().
+ * manner equivalent to using boost::asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(boost::system::error_code, Iterator) @endcode
@@ -1161,14 +1318,23 @@ template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-auto async_connect(basic_socket<Protocol, Executor>& s,
+inline auto async_connect(basic_socket<Protocol, Executor>& s,
     Iterator begin, Iterator end, ConnectCondition connect_condition,
-    IteratorConnectToken&& token = default_completion_token_t<Executor>())
+    IteratorConnectToken&& token = default_completion_token_t<Executor>(),
+    constraint_t<
+      is_connect_condition<ConnectCondition, Iterator>::value
+    > = 0)
   -> decltype(
     async_initiate<IteratorConnectToken,
       void (boost::system::error_code, Iterator)>(
         declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, end, connect_condition));
+        token, begin, end, connect_condition))
+{
+  return async_initiate<IteratorConnectToken,
+    void (boost::system::error_code, Iterator)>(
+      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
+      token, begin, end, connect_condition);
+}
 
 /*@}*/
 
@@ -1179,4 +1345,4 @@ auto async_connect(basic_socket<Protocol, Executor>& s,
 
 #include <boost/asio/impl/connect.hpp>
 
-#endif
+#endif // BOOST_ASIO_CONNECT_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/coroutine.hpp

@@ -201,7 +201,7 @@ class coroutine_ref;
  * The @c fork pseudo-keyword is used when "forking" a coroutine, i.e. splitting
  * it into two (or more) copies. One use of @c fork is in a server, where a new
  * coroutine is created to handle each client connection:
- * 
+ *
  * @code reenter (this)
  * {
  *   do
@@ -212,9 +212,9 @@ class coroutine_ref;
  *   } while (is_parent());
  *   ... client-specific handling follows ...
  * } @endcode
- * 
+ *
  * The logical steps involved in a @c fork are:
- * 
+ *
  * @li @c fork saves the current state of the coroutine.
  * @li The statement creates a copy of the coroutine and either executes it
  *     immediately or schedules it for later execution.
@@ -259,7 +259,6 @@ private:
   int value_;
 };
 
-
 namespace detail {
 
 class coroutine_ref

data/src/cxx_supportlib/vendor-modified/boost/asio/default_completion_token.hpp

@@ -0,0 +1,91 @@
+//
+// default_completion_token.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 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 BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_HPP
+#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+class deferred_t;
+
+namespace detail {
+
+template <typename T, typename = void>
+struct default_completion_token_impl
+{
+  typedef deferred_t type;
+};
+
+template <typename T>
+struct default_completion_token_impl<T,
+    void_t<typename T::default_completion_token_type>
+  >
+{
+  typedef typename T::default_completion_token_type type;
+};
+
+} // namespace detail
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// Traits type used to determine the default completion token type associated
+/// with a type (such as an executor).
+/**
+ * A program may specialise this traits type if the @c T template parameter in
+ * the specialisation is a user-defined type.
+ *
+ * Specialisations of this trait may provide a nested typedef @c type, which is
+ * a default-constructible completion token type.
+ *
+ * If not otherwise specialised, the default completion token type is
+ * boost::asio::deferred_t.
+ */
+template <typename T>
+struct default_completion_token
+{
+  /// If @c T has a nested type @c default_completion_token_type,
+  /// <tt>T::default_completion_token_type</tt>. Otherwise the typedef @c type
+  /// is boost::asio::deferred_t.
+  typedef see_below type;
+};
+#else
+template <typename T>
+struct default_completion_token
+  : detail::default_completion_token_impl<T>
+{
+};
+#endif
+
+template <typename T>
+using default_completion_token_t = typename default_completion_token<T>::type;
+
+#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) \
+  = typename ::boost::asio::default_completion_token<e>::type
+#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(e) \
+  = typename ::boost::asio::default_completion_token<e>::type()
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/deferred.hpp>
+
+#endif // BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/deferred.hpp

@@ -185,7 +185,7 @@ template <typename Function>
 class deferred_function
 {
 public:
-  /// Constructor. 
+  /// Constructor.
   template <typename F>
   constexpr explicit deferred_function(deferred_init_tag, F&& function)
     : function_(static_cast<F&&>(function))
@@ -326,7 +326,8 @@ private:
       detail::index_sequence<I...>) const &
     -> decltype(
       async_initiate<CompletionToken, Signature>(
-        initiation_t(initiation_), token, std::get<I>(init_args_)...))
+        conditional_t<true, initiation_t, CompletionToken>(initiation_),
+        token, std::get<I>(init_args_)...))
   {
     return async_initiate<CompletionToken, Signature>(
         initiation_t(initiation_), token, std::get<I>(init_args_)...);
@@ -593,8 +594,11 @@ struct is_deferred<deferred_conditional<OnTrue, OnFalse>> : true_type
  * The deferred_t class is used to indicate that an asynchronous operation
  * should return a function object which is itself an initiation function. A
  * deferred_t object may be passed as a completion token to an asynchronous
- * operation, typically using the special value @c boost::asio::deferred. For
- * example:
+ * operation, typically as the default completion token:
+ *
+ * @code auto my_deferred_op = my_socket.async_read_some(my_buffer); @endcode
+ *
+ * or by explicitly passing the special value @c boost::asio::deferred:
  *
  * @code auto my_deferred_op
  *   = my_socket.async_read_some(my_buffer,
@@ -705,7 +709,7 @@ inline auto operator|(Head head, Tail&& tail)
 /**
  * See the documentation for boost::asio::deferred_t for a usage example.
  */
-constexpr deferred_t deferred;
+BOOST_ASIO_INLINE_VARIABLE constexpr deferred_t deferred;
 
 } // namespace asio
 } // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/asio/detached.hpp

@@ -39,7 +39,7 @@ namespace asio {
 class detached_t
 {
 public:
-  /// Constructor. 
+  /// Constructor.
   constexpr detached_t()
   {
   }
@@ -95,7 +95,7 @@ public:
 /**
  * See the documentation for boost::asio::detached_t for a usage example.
  */
-constexpr detached_t detached;
+BOOST_ASIO_INLINE_VARIABLE constexpr detached_t detached;
 
 } // namespace asio
 } // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/buffered_stream_storage.hpp

@@ -114,7 +114,7 @@ private:
 
   // The offset to the end of the unread data.
   size_type end_offset_;
-  
+
   // The data in the buffer.
   std::vector<byte_type> buffer_;
 };