passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // prefer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
@@ -120,10 +120,10 @@ struct prefer_result
 
 namespace boost_asio_prefer_fn {
 
-using boost::asio::conditional;
-using boost::asio::decay;
+using boost::asio::conditional_t;
+using boost::asio::decay_t;
 using boost::asio::declval;
-using boost::asio::enable_if;
+using boost::asio::enable_if_t;
 using boost::asio::is_applicable_property;
 using boost::asio::traits::prefer_free;
 using boost::asio::traits::prefer_member;
@@ -151,195 +151,187 @@ template <typename Impl, typename T, typename Properties,
     typename = void, typename = void, typename = void>
 struct call_traits
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed);
-  BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false);
+  static constexpr overload_type overload = ill_formed;
+  static constexpr bool is_noexcept = false;
   typedef void result_type;
 };
 
 template <typename Impl, typename T, typename Property>
 struct call_traits<Impl, T, void(Property),
-  typename enable_if<
+  enable_if_t<
     is_applicable_property<
-      typename decay<T>::type,
-      typename decay<Property>::type
+      decay_t<T>,
+      decay_t<Property>
     >::value
-  >::type,
-  typename enable_if<
-    decay<Property>::type::is_preferable
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
+    decay_t<Property>::is_preferable
+  >,
+  enable_if_t<
     static_require<T, Property>::is_valid
-  >::type>
+  >>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
-  BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-  typedef BOOST_ASIO_MOVE_ARG(T) result_type;
-#else // defined(BOOST_ASIO_HAS_MOVE)
-  typedef BOOST_ASIO_MOVE_ARG(typename decay<T>::type) result_type;
-#endif // defined(BOOST_ASIO_HAS_MOVE)
+  static constexpr overload_type overload = identity;
+  static constexpr bool is_noexcept = true;
+
+  typedef T&& result_type;
 };
 
 template <typename Impl, typename T, typename Property>
 struct call_traits<Impl, T, void(Property),
-  typename enable_if<
+  enable_if_t<
     is_applicable_property<
-      typename decay<T>::type,
-      typename decay<Property>::type
+      decay_t<T>,
+      decay_t<Property>
     >::value
-  >::type,
-  typename enable_if<
-    decay<Property>::type::is_preferable
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
+    decay_t<Property>::is_preferable
+  >,
+  enable_if_t<
     !static_require<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type> :
+  >> :
   require_member<typename Impl::template proxy<T>::type, Property>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_member);
+  static constexpr overload_type overload = call_require_member;
 };
 
 template <typename Impl, typename T, typename Property>
 struct call_traits<Impl, T, void(Property),
-  typename enable_if<
+  enable_if_t<
     is_applicable_property<
-      typename decay<T>::type,
-      typename decay<Property>::type
+      decay_t<T>,
+      decay_t<Property>
     >::value
-  >::type,
-  typename enable_if<
-    decay<Property>::type::is_preferable
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
+    decay_t<Property>::is_preferable
+  >,
+  enable_if_t<
     !static_require<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     require_free<T, Property>::is_valid
-  >::type> :
+  >> :
   require_free<T, Property>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_free);
+  static constexpr overload_type overload = call_require_free;
 };
 
 template <typename Impl, typename T, typename Property>
 struct call_traits<Impl, T, void(Property),
-  typename enable_if<
+  enable_if_t<
     is_applicable_property<
-      typename decay<T>::type,
-      typename decay<Property>::type
+      decay_t<T>,
+      decay_t<Property>
     >::value
-  >::type,
-  typename enable_if<
-    decay<Property>::type::is_preferable
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
+    decay_t<Property>::is_preferable
+  >,
+  enable_if_t<
     !static_require<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_free<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type> :
+  >> :
   prefer_member<typename Impl::template proxy<T>::type, Property>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_member);
+  static constexpr overload_type overload = call_prefer_member;
 };
 
 template <typename Impl, typename T, typename Property>
 struct call_traits<Impl, T, void(Property),
-  typename enable_if<
+  enable_if_t<
     is_applicable_property<
-      typename decay<T>::type,
-      typename decay<Property>::type
+      decay_t<T>,
+      decay_t<Property>
     >::value
-  >::type,
-  typename enable_if<
-    decay<Property>::type::is_preferable
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
+    decay_t<Property>::is_preferable
+  >,
+  enable_if_t<
     !static_require<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_free<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     prefer_free<T, Property>::is_valid
-  >::type> :
+  >> :
   prefer_free<T, Property>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_free);
+  static constexpr overload_type overload = call_prefer_free;
 };
 
 template <typename Impl, typename T, typename Property>
 struct call_traits<Impl, T, void(Property),
-  typename enable_if<
+  enable_if_t<
     is_applicable_property<
-      typename decay<T>::type,
-      typename decay<Property>::type
+      decay_t<T>,
+      decay_t<Property>
     >::value
-  >::type,
-  typename enable_if<
-    decay<Property>::type::is_preferable
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
+    decay_t<Property>::is_preferable
+  >,
+  enable_if_t<
     !static_require<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !require_free<T, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     !prefer_free<T, Property>::is_valid
-  >::type>
+  >>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
-  BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-  typedef BOOST_ASIO_MOVE_ARG(T) result_type;
-#else // defined(BOOST_ASIO_HAS_MOVE)
-  typedef BOOST_ASIO_MOVE_ARG(typename decay<T>::type) result_type;
-#endif // defined(BOOST_ASIO_HAS_MOVE)
+  static constexpr overload_type overload = identity;
+  static constexpr bool is_noexcept = true;
+
+  typedef T&& result_type;
 };
 
 template <typename Impl, typename T, typename P0, typename P1>
 struct call_traits<Impl, T, void(P0, P1),
-  typename enable_if<
+  enable_if_t<
     call_traits<Impl, T, void(P0)>::overload != ill_formed
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     call_traits<
       Impl,
       typename call_traits<Impl, T, void(P0)>::result_type,
       void(P1)
     >::overload != ill_formed
-  >::type>
+  >>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = two_props);
+  static constexpr overload_type overload = two_props;
 
-  BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
+  static constexpr bool is_noexcept =
     (
       call_traits<Impl, T, void(P0)>::is_noexcept
       &&
@@ -348,51 +340,51 @@ struct call_traits<Impl, T, void(P0, P1),
         typename call_traits<Impl, T, void(P0)>::result_type,
         void(P1)
       >::is_noexcept
-    ));
+    );
 
-  typedef typename decay<
+  typedef decay_t<
     typename call_traits<
       Impl,
       typename call_traits<Impl, T, void(P0)>::result_type,
       void(P1)
     >::result_type
-  >::type result_type;
+  > result_type;
 };
 
 template <typename Impl, typename T, typename P0,
-    typename P1, typename BOOST_ASIO_ELLIPSIS PN>
-struct call_traits<Impl, T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS),
-  typename enable_if<
+    typename P1, typename... PN>
+struct call_traits<Impl, T, void(P0, P1, PN...),
+  enable_if_t<
     call_traits<Impl, T, void(P0)>::overload != ill_formed
-  >::type,
-  typename enable_if<
+  >,
+  enable_if_t<
     call_traits<
       Impl,
       typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1, PN BOOST_ASIO_ELLIPSIS)
+      void(P1, PN...)
     >::overload != ill_formed
-  >::type>
+  >>
 {
-  BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = n_props);
+  static constexpr overload_type overload = n_props;
 
-  BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
+  static constexpr bool is_noexcept =
     (
       call_traits<Impl, T, void(P0)>::is_noexcept
       &&
       call_traits<
         Impl,
         typename call_traits<Impl, T, void(P0)>::result_type,
-        void(P1, PN BOOST_ASIO_ELLIPSIS)
+        void(P1, PN...)
       >::is_noexcept
-    ));
+    );
 
-  typedef typename decay<
+  typedef decay_t<
     typename call_traits<
       Impl,
       typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1, PN BOOST_ASIO_ELLIPSIS)
+      void(P1, PN...)
     >::result_type
-  >::type result_type;
+  > result_type;
 };
 
 struct impl
@@ -405,29 +397,25 @@ struct impl
     struct type
     {
       template <typename P>
-      auto require(BOOST_ASIO_MOVE_ARG(P) p)
+      auto require(P&& p)
         noexcept(
           noexcept(
-            declval<typename conditional<true, T, P>::type>().require(
-              BOOST_ASIO_MOVE_CAST(P)(p))
+            declval<conditional_t<true, T, P>>().require(static_cast<P&&>(p))
           )
         )
         -> decltype(
-          declval<typename conditional<true, T, P>::type>().require(
-            BOOST_ASIO_MOVE_CAST(P)(p))
+          declval<conditional_t<true, T, P>>().require(static_cast<P&&>(p))
         );
 
       template <typename P>
-      auto prefer(BOOST_ASIO_MOVE_ARG(P) p)
+      auto prefer(P&& p)
         noexcept(
           noexcept(
-            declval<typename conditional<true, T, P>::type>().prefer(
-              BOOST_ASIO_MOVE_CAST(P)(p))
+            declval<conditional_t<true, T, P>>().prefer(static_cast<P&&>(p))
           )
         )
         -> decltype(
-          declval<typename conditional<true, T, P>::type>().prefer(
-            BOOST_ASIO_MOVE_CAST(P)(p))
+          declval<conditional_t<true, T, P>>().prefer(static_cast<P&&>(p))
         );
     };
 #else // defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
@@ -438,122 +426,85 @@ struct impl
   };
 
   template <typename T, typename Property>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
     call_traits<impl, T, void(Property)>::overload == identity,
     typename call_traits<impl, T, void(Property)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(Property)) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(Property)>::is_noexcept))
+  >
+  operator()(T&& t, Property&&) const
+    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
   {
-    return BOOST_ASIO_MOVE_CAST(T)(t);
+    return static_cast<T&&>(t);
   }
 
   template <typename T, typename Property>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
     call_traits<impl, T, void(Property)>::overload == call_require_member,
     typename call_traits<impl, T, void(Property)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(Property) p) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(Property)>::is_noexcept))
+  >
+  operator()(T&& t, Property&& p) const
+    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
   {
-    return BOOST_ASIO_MOVE_CAST(T)(t).require(
-        BOOST_ASIO_MOVE_CAST(Property)(p));
+    return static_cast<T&&>(t).require(static_cast<Property&&>(p));
   }
 
   template <typename T, typename Property>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
     call_traits<impl, T, void(Property)>::overload == call_require_free,
     typename call_traits<impl, T, void(Property)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(Property) p) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(Property)>::is_noexcept))
+  >
+  operator()(T&& t, Property&& p) const
+    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
   {
-    return require(
-        BOOST_ASIO_MOVE_CAST(T)(t),
-        BOOST_ASIO_MOVE_CAST(Property)(p));
+    return require(static_cast<T&&>(t), static_cast<Property&&>(p));
   }
 
   template <typename T, typename Property>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
     call_traits<impl, T, void(Property)>::overload == call_prefer_member,
     typename call_traits<impl, T, void(Property)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(Property) p) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(Property)>::is_noexcept))
+  >
+  operator()(T&& t, Property&& p) const
+    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
   {
-    return BOOST_ASIO_MOVE_CAST(T)(t).prefer(
-        BOOST_ASIO_MOVE_CAST(Property)(p));
+    return static_cast<T&&>(t).prefer(static_cast<Property&&>(p));
   }
 
   template <typename T, typename Property>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
     call_traits<impl, T, void(Property)>::overload == call_prefer_free,
     typename call_traits<impl, T, void(Property)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(Property) p) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(Property)>::is_noexcept))
+  >
+  operator()(T&& t, Property&& p) const
+    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
   {
-    return prefer(
-        BOOST_ASIO_MOVE_CAST(T)(t),
-        BOOST_ASIO_MOVE_CAST(Property)(p));
+    return prefer(static_cast<T&&>(t), static_cast<Property&&>(p));
   }
 
   template <typename T, typename P0, typename P1>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
     call_traits<impl, T, void(P0, P1)>::overload == two_props,
     typename call_traits<impl, T, void(P0, P1)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(P0) p0,
-      BOOST_ASIO_MOVE_ARG(P1) p1) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(P0, P1)>::is_noexcept))
+  >
+  operator()(T&& t, P0&& p0, P1&& p1) const
+    noexcept(call_traits<impl, T, void(P0, P1)>::is_noexcept)
   {
     return (*this)(
-        (*this)(
-          BOOST_ASIO_MOVE_CAST(T)(t),
-          BOOST_ASIO_MOVE_CAST(P0)(p0)),
-        BOOST_ASIO_MOVE_CAST(P1)(p1));
+        (*this)(static_cast<T&&>(t), static_cast<P0&&>(p0)),
+        static_cast<P1&&>(p1));
   }
 
   template <typename T, typename P0, typename P1,
-    typename BOOST_ASIO_ELLIPSIS PN>
-  BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<impl, T,
-      void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::overload == n_props,
-    typename call_traits<impl, T,
-      void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::result_type
-  >::type
-  operator()(
-      BOOST_ASIO_MOVE_ARG(T) t,
-      BOOST_ASIO_MOVE_ARG(P0) p0,
-      BOOST_ASIO_MOVE_ARG(P1) p1,
-      BOOST_ASIO_MOVE_ARG(PN) BOOST_ASIO_ELLIPSIS pn) const
-    BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<impl, T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::is_noexcept))
+    typename... PN>
+  BOOST_ASIO_NODISCARD constexpr enable_if_t<
+    call_traits<impl, T, void(P0, P1, PN...)>::overload == n_props,
+    typename call_traits<impl, T, void(P0, P1, PN...)>::result_type
+  >
+  operator()(T&& t, P0&& p0, P1&& p1, PN&&... pn) const
+    noexcept(call_traits<impl, T, void(P0, P1, PN...)>::is_noexcept)
   {
     return (*this)(
-        (*this)(
-          BOOST_ASIO_MOVE_CAST(T)(t),
-          BOOST_ASIO_MOVE_CAST(P0)(p0)),
-        BOOST_ASIO_MOVE_CAST(P1)(p1),
-        BOOST_ASIO_MOVE_CAST(PN)(pn) BOOST_ASIO_ELLIPSIS);
+        (*this)(static_cast<T&&>(t), static_cast<P0&&>(p0)),
+        static_cast<P1&&>(p1), static_cast<PN&&>(pn)...);
   }
 };
 
@@ -571,15 +522,13 @@ namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const boost_asio_prefer_fn::impl&
+static constexpr const boost_asio_prefer_fn::impl&
   prefer = boost_asio_prefer_fn::static_instance<>::instance;
 
 } // namespace
 
 typedef boost_asio_prefer_fn::impl prefer_t;
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <typename T, typename... Properties>
 struct can_prefer :
   integral_constant<bool,
@@ -589,54 +538,14 @@ struct can_prefer :
 {
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename T, typename P0 = void,
-    typename P1 = void, typename P2 = void>
-struct can_prefer :
-  integral_constant<bool,
-    boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0, P1, P2)>::overload
-        != boost_asio_prefer_fn::ill_formed>
-{
-};
-
-template <typename T, typename P0, typename P1>
-struct can_prefer<T, P0, P1> :
-  integral_constant<bool,
-    boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0, P1)>::overload
-        != boost_asio_prefer_fn::ill_formed>
-{
-};
-
-template <typename T, typename P0>
-struct can_prefer<T, P0> :
-  integral_constant<bool,
-    boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0)>::overload
-        != boost_asio_prefer_fn::ill_formed>
-{
-};
-
-template <typename T>
-struct can_prefer<T> :
-  false_type
-{
-};
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
-template <typename T, typename BOOST_ASIO_ELLIPSIS Properties>
+template <typename T, typename... Properties>
 constexpr bool can_prefer_v
-  = can_prefer<T, Properties BOOST_ASIO_ELLIPSIS>::value;
+  = can_prefer<T, Properties...>::value;
 
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <typename T, typename... Properties>
 struct is_nothrow_prefer :
   integral_constant<bool,
@@ -645,51 +554,13 @@ struct is_nothrow_prefer :
 {
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename T, typename P0 = void,
-    typename P1 = void, typename P2 = void>
-struct is_nothrow_prefer :
-  integral_constant<bool,
-    boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0, P1, P2)>::is_noexcept>
-{
-};
-
-template <typename T, typename P0, typename P1>
-struct is_nothrow_prefer<T, P0, P1> :
-  integral_constant<bool,
-    boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0, P1)>::is_noexcept>
-{
-};
-
-template <typename T, typename P0>
-struct is_nothrow_prefer<T, P0> :
-  integral_constant<bool,
-    boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0)>::is_noexcept>
-{
-};
-
-template <typename T>
-struct is_nothrow_prefer<T> :
-  false_type
-{
-};
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
-template <typename T, typename BOOST_ASIO_ELLIPSIS Properties>
-constexpr bool is_nothrow_prefer_v
-  = is_nothrow_prefer<T, Properties BOOST_ASIO_ELLIPSIS>::value;
+template <typename T, typename... Properties>
+constexpr bool is_nothrow_prefer_v = is_nothrow_prefer<T, Properties...>::value;
 
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <typename T, typename... Properties>
 struct prefer_result
 {
@@ -697,36 +568,8 @@ struct prefer_result
       prefer_t, T, void(Properties...)>::result_type type;
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename T, typename P0 = void,
-    typename P1 = void, typename P2 = void>
-struct prefer_result
-{
-  typedef typename boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0, P1, P2)>::result_type type;
-};
-
-template <typename T, typename P0, typename P1>
-struct prefer_result<T, P0, P1>
-{
-  typedef typename boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0, P1)>::result_type type;
-};
-
-template <typename T, typename P0>
-struct prefer_result<T, P0>
-{
-  typedef typename boost_asio_prefer_fn::call_traits<
-      prefer_t, T, void(P0)>::result_type type;
-};
-
-template <typename T>
-struct prefer_result<T>
-{
-};
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+template <typename T, typename... Properties>
+using prefer_result_t = typename prefer_result<T, Properties...>::type;
 
 } // namespace asio
 } // namespace boost