passenger 6.0.19 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/any_executor.hpp

@@ -2,7 +2,7 @@
 // execution/any_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2022 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)
@@ -27,10 +27,8 @@
 #include <boost/asio/detail/scoped_ptr.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/detail/throw_exception.hpp>
-#include <boost/asio/detail/variadic_templates.hpp>
 #include <boost/asio/execution/bad_executor.hpp>
 #include <boost/asio/execution/blocking.hpp>
-#include <boost/asio/execution/execute.hpp>
 #include <boost/asio/execution/executor.hpp>
 #include <boost/asio/prefer.hpp>
 #include <boost/asio/query.hpp>
@@ -230,20 +228,9 @@ namespace execution {
 #if !defined(BOOST_ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
 #define BOOST_ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <typename... SupportableProperties>
 class any_executor;
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename = void, typename = void, typename = void,
-    typename = void, typename = void, typename = void,
-    typename = void, typename = void, typename = void>
-class any_executor;
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 #endif // !defined(BOOST_ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
 
 template <typename U>
@@ -259,15 +246,13 @@ template <typename T, typename = void>
 struct is_requirable : false_type {};
 
 template <typename T>
-struct is_requirable<T, typename enable_if<T::is_requirable>::type> :
-  true_type {};
+struct is_requirable<T, enable_if_t<T::is_requirable>> : true_type {};
 
 template <typename T, typename = void>
 struct is_preferable : false_type {};
 
 template <typename T>
-struct is_preferable<T, typename enable_if<T::is_preferable>::type> :
-  true_type {};
+struct is_preferable<T, enable_if_t<T::is_preferable>> : true_type {};
 
 // Trait used to detect context_as property, for backward compatibility.
 
@@ -275,7 +260,7 @@ template <typename T>
 struct is_context_as : false_type {};
 
 template <typename U>
-struct is_context_as<context_as_t<U> > : true_type {};
+struct is_context_as<context_as_t<U>> : true_type {};
 
 // Helper template to:
 // - Check if a target can supply the supportable properties.
@@ -312,53 +297,51 @@ struct supportable_properties<I, void(Prop)>
 
   struct found
   {
-    BOOST_ASIO_STATIC_CONSTEXPR(bool, value = true);
+    static constexpr bool value = true;
     typedef Prop type;
     typedef typename Prop::polymorphic_query_result_type query_result_type;
-    BOOST_ASIO_STATIC_CONSTEXPR(std::size_t, index = I);
+    static constexpr std::size_t index = I;
   };
 
   struct not_found
   {
-    BOOST_ASIO_STATIC_CONSTEXPR(bool, value = false);
+    static constexpr bool value = false;
   };
 
   template <typename T>
   struct find_convertible_property :
-      conditional<
+      conditional_t<
         is_same<T, Prop>::value || is_convertible<T, Prop>::value,
         found,
         not_found
-      >::type {};
+      > {};
 
   template <typename T>
   struct find_convertible_requirable_property :
-      conditional<
+      conditional_t<
         is_requirable<Prop>::value
           && (is_same<T, Prop>::value || is_convertible<T, Prop>::value),
         found,
         not_found
-      >::type {};
+      > {};
 
   template <typename T>
   struct find_convertible_preferable_property :
-      conditional<
+      conditional_t<
         is_preferable<Prop>::value
           && (is_same<T, Prop>::value || is_convertible<T, Prop>::value),
         found,
         not_found
-      >::type {};
+      > {};
 
   struct find_context_as_property :
-      conditional<
+      conditional_t<
         is_context_as<Prop>::value,
         found,
         not_found
-      >::type {};
+      > {};
 };
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <std::size_t I, typename Head, typename... Tail>
 struct supportable_properties<I, void(Head, Tail...)>
 {
@@ -377,117 +360,49 @@ struct supportable_properties<I, void(Head, Tail...)>
 
   template <typename T>
   struct find_convertible_property :
-      conditional<
+      conditional_t<
         is_convertible<T, Head>::value,
         typename supportable_properties<I, void(Head)>::found,
         typename supportable_properties<I + 1,
             void(Tail...)>::template find_convertible_property<T>
-      >::type {};
+      > {};
 
   template <typename T>
   struct find_convertible_requirable_property :
-      conditional<
+      conditional_t<
         is_requirable<Head>::value
           && is_convertible<T, Head>::value,
         typename supportable_properties<I, void(Head)>::found,
         typename supportable_properties<I + 1,
             void(Tail...)>::template find_convertible_requirable_property<T>
-      >::type {};
+      > {};
 
   template <typename T>
   struct find_convertible_preferable_property :
-      conditional<
+      conditional_t<
         is_preferable<Head>::value
           && is_convertible<T, Head>::value,
         typename supportable_properties<I, void(Head)>::found,
         typename supportable_properties<I + 1,
             void(Tail...)>::template find_convertible_preferable_property<T>
-      >::type {};
+      > {};
 
   struct find_context_as_property :
-      conditional<
+      conditional_t<
         is_context_as<Head>::value,
         typename supportable_properties<I, void(Head)>::found,
         typename supportable_properties<I + 1,
             void(Tail...)>::find_context_as_property
-      >::type {};
+      > {};
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROPS_BASE_DEF(n) \
-  template <std::size_t I, \
-    typename Head, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct supportable_properties<I, \
-      void(Head, BOOST_ASIO_VARIADIC_TARGS(n))> \
-  { \
-    template <typename T> \
-    struct is_valid_target : integral_constant<bool, \
-        ( \
-          supportable_properties<I, \
-            void(Head)>::template is_valid_target<T>::value \
-          && \
-          supportable_properties<I + 1, \
-              void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-                is_valid_target<T>::value \
-        ) \
-      > \
-    { \
-    }; \
-  \
-    template <typename T> \
-    struct find_convertible_property : \
-        conditional< \
-          is_convertible<T, Head>::value, \
-          typename supportable_properties<I, void(Head)>::found, \
-          typename supportable_properties<I + 1, \
-              void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-                find_convertible_property<T> \
-        >::type {}; \
-  \
-    template <typename T> \
-    struct find_convertible_requirable_property : \
-        conditional< \
-          is_requirable<Head>::value \
-            && is_convertible<T, Head>::value, \
-          typename supportable_properties<I, void(Head)>::found, \
-          typename supportable_properties<I + 1, \
-              void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-                find_convertible_requirable_property<T> \
-        >::type {}; \
-  \
-    template <typename T> \
-    struct find_convertible_preferable_property : \
-        conditional< \
-          is_preferable<Head>::value \
-            && is_convertible<T, Head>::value, \
-          typename supportable_properties<I, void(Head)>::found, \
-          typename supportable_properties<I + 1, \
-              void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-                find_convertible_preferable_property<T> \
-        >::type {}; \
-  \
-    struct find_context_as_property : \
-        conditional< \
-          is_context_as<Head>::value, \
-          typename supportable_properties<I, void(Head)>::found, \
-          typename supportable_properties<I + 1, void( \
-            BOOST_ASIO_VARIADIC_TARGS(n))>::find_context_as_property \
-        >::type {}; \
-  }; \
-  /**/
-BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROPS_BASE_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROPS_BASE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <typename T, typename Props>
 struct is_valid_target_executor :
-  conditional<
+  conditional_t<
     is_executor<T>::value,
     typename supportable_properties<0, Props>::template is_valid_target<T>,
     false_type
-  >::type
+  >
 {
 };
 
@@ -500,60 +415,36 @@ class shared_target_executor
 {
 public:
   template <typename E>
-  shared_target_executor(BOOST_ASIO_MOVE_ARG(E) e,
-      typename decay<E>::type*& target)
+  shared_target_executor(E&& e, decay_t<E>*& target)
   {
-    impl<typename decay<E>::type>* i =
-      new impl<typename decay<E>::type>(BOOST_ASIO_MOVE_CAST(E)(e));
+    impl<decay_t<E>>* i =
+      new impl<decay_t<E>>(static_cast<E&&>(e));
     target = &i->ex_;
     impl_ = i;
   }
 
   template <typename E>
-  shared_target_executor(std::nothrow_t, BOOST_ASIO_MOVE_ARG(E) e,
-      typename decay<E>::type*& target) BOOST_ASIO_NOEXCEPT
+  shared_target_executor(std::nothrow_t, E&& e, decay_t<E>*& target) noexcept
   {
-    impl<typename decay<E>::type>* i =
-      new (std::nothrow) impl<typename decay<E>::type>(
-        BOOST_ASIO_MOVE_CAST(E)(e));
+    impl<decay_t<E>>* i =
+      new (std::nothrow) impl<decay_t<E>>(static_cast<E&&>(e));
     target = i ? &i->ex_ : 0;
     impl_ = i;
   }
 
-  shared_target_executor(
-      const shared_target_executor& other) BOOST_ASIO_NOEXCEPT
+  shared_target_executor(const shared_target_executor& other) noexcept
     : impl_(other.impl_)
   {
     if (impl_)
       boost::asio::detail::ref_count_up(impl_->ref_count_);
   }
 
-  shared_target_executor& operator=(
-      const shared_target_executor& other) BOOST_ASIO_NOEXCEPT
-  {
-    impl_ = other.impl_;
-    if (impl_)
-      boost::asio::detail::ref_count_up(impl_->ref_count_);
-    return *this;
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-  shared_target_executor(
-      shared_target_executor&& other) BOOST_ASIO_NOEXCEPT
+  shared_target_executor(shared_target_executor&& other) noexcept
     : impl_(other.impl_)
   {
     other.impl_ = 0;
   }
 
-  shared_target_executor& operator=(
-      shared_target_executor&& other) BOOST_ASIO_NOEXCEPT
-  {
-    impl_ = other.impl_;
-    other.impl_ = 0;
-    return *this;
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   ~shared_target_executor()
   {
     if (impl_)
@@ -561,12 +452,18 @@ public:
         delete impl_;
   }
 
-  void* get() const BOOST_ASIO_NOEXCEPT
+  void* get() const noexcept
   {
     return impl_ ? impl_->get() : 0;
   }
 
 private:
+  shared_target_executor& operator=(
+      const shared_target_executor& other) = delete;
+
+  shared_target_executor& operator=(
+      shared_target_executor&& other) = delete;
+
   struct impl_base
   {
     impl_base() : ref_count_(1) {}
@@ -578,7 +475,7 @@ private:
   template <typename Executor>
   struct impl : impl_base
   {
-    impl(Executor ex) : ex_(BOOST_ASIO_MOVE_CAST(Executor)(ex)) {}
+    impl(Executor ex) : ex_(static_cast<Executor&&>(ex)) {}
     virtual void* get() { return &ex_; }
     Executor ex_;
   };
@@ -589,7 +486,7 @@ private:
 class any_executor_base
 {
 public:
-  any_executor_base() BOOST_ASIO_NOEXCEPT
+  any_executor_base() noexcept
     : object_fns_(0),
       target_(0),
       target_fns_(0)
@@ -611,7 +508,7 @@ public:
   }
 
   template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
-  any_executor_base(std::nothrow_t, Executor ex, false_type) BOOST_ASIO_NOEXCEPT
+  any_executor_base(std::nothrow_t, Executor ex, false_type) noexcept
     : target_fns_(target_fns_table<Executor>(
           any_executor_base::query_blocking(ex,
             can_query<const Executor&, const execution::blocking_t&>())
@@ -636,19 +533,19 @@ public:
   {
     Executor* p = 0;
     new (&object_) shared_target_executor(
-        BOOST_ASIO_MOVE_CAST(Executor)(other), p);
+        static_cast<Executor&&>(other), p);
     target_ = p->template target<void>();
   }
 
   template <BOOST_ASIO_EXECUTION_EXECUTOR Executor>
   any_executor_base(std::nothrow_t,
-      Executor other, true_type) BOOST_ASIO_NOEXCEPT
+      Executor other, true_type) noexcept
     : object_fns_(object_fns_table<shared_target_executor>()),
       target_fns_(other.target_fns_)
   {
     Executor* p = 0;
     new (&object_) shared_target_executor(
-        std::nothrow, BOOST_ASIO_MOVE_CAST(Executor)(other), p);
+        std::nothrow, static_cast<Executor&&>(other), p);
     if (p)
       target_ = p->template target<void>();
     else
@@ -659,7 +556,7 @@ public:
     }
   }
 
-  any_executor_base(const any_executor_base& other) BOOST_ASIO_NOEXCEPT
+  any_executor_base(const any_executor_base& other) noexcept
   {
     if (!!other)
     {
@@ -675,14 +572,14 @@ public:
     }
   }
 
-  ~any_executor_base() BOOST_ASIO_NOEXCEPT
+  ~any_executor_base() noexcept
   {
     if (!!*this)
       object_fns_->destroy(*this);
   }
 
   any_executor_base& operator=(
-      const any_executor_base& other) BOOST_ASIO_NOEXCEPT
+      const any_executor_base& other) noexcept
   {
     if (this != &other)
     {
@@ -704,7 +601,7 @@ public:
     return *this;
   }
 
-  any_executor_base& operator=(nullptr_t) BOOST_ASIO_NOEXCEPT
+  any_executor_base& operator=(nullptr_t) noexcept
   {
     if (target_)
       object_fns_->destroy(*this);
@@ -714,9 +611,7 @@ public:
     return *this;
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-
-  any_executor_base(any_executor_base&& other) BOOST_ASIO_NOEXCEPT
+  any_executor_base(any_executor_base&& other) noexcept
   {
     if (other.target_)
     {
@@ -736,7 +631,7 @@ public:
   }
 
   any_executor_base& operator=(
-      any_executor_base&& other) BOOST_ASIO_NOEXCEPT
+      any_executor_base&& other) noexcept
   {
     if (this != &other)
     {
@@ -761,20 +656,18 @@ public:
     return *this;
   }
 
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-  void swap(any_executor_base& other) BOOST_ASIO_NOEXCEPT
+  void swap(any_executor_base& other) noexcept
   {
     if (this != &other)
     {
-      any_executor_base tmp(BOOST_ASIO_MOVE_CAST(any_executor_base)(other));
-      other = BOOST_ASIO_MOVE_CAST(any_executor_base)(*this);
-      *this = BOOST_ASIO_MOVE_CAST(any_executor_base)(tmp);
+      any_executor_base tmp(static_cast<any_executor_base&&>(other));
+      other = static_cast<any_executor_base&&>(*this);
+      *this = static_cast<any_executor_base&&>(tmp);
     }
   }
 
   template <typename F>
-  void execute(BOOST_ASIO_MOVE_ARG(F) f) const
+  void execute(F&& f) const
   {
     if (target_)
     {
@@ -786,7 +679,7 @@ public:
       else
       {
         target_fns_->execute(*this,
-            function(BOOST_ASIO_MOVE_CAST(F)(f), std::allocator<void>()));
+            function(static_cast<F&&>(f), std::allocator<void>()));
       }
     }
     else
@@ -828,18 +721,18 @@ public:
   typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
   static void unspecified_bool_true(unspecified_bool_type_t) {}
 
-  operator unspecified_bool_type() const BOOST_ASIO_NOEXCEPT
+  operator unspecified_bool_type() const noexcept
   {
     return target_ ? &any_executor_base::unspecified_bool_true : 0;
   }
 
-  bool operator!() const BOOST_ASIO_NOEXCEPT
+  bool operator!() const noexcept
   {
     return target_ == 0;
   }
 
 protected:
-  bool equality_helper(const any_executor_base& other) const BOOST_ASIO_NOEXCEPT
+  bool equality_helper(const any_executor_base& other) const noexcept
   {
     if (target_ == other.target_)
       return true;
@@ -888,7 +781,7 @@ protected:
   static void move_shared(any_executor_base& ex1, any_executor_base& ex2)
   {
     typedef shared_target_executor type;
-    new (&ex1.object_) type(BOOST_ASIO_MOVE_CAST(type)(ex2.object<type>()));
+    new (&ex1.object_) type(static_cast<type&&>(ex2.object<type>()));
     ex1.target_ = ex2.target_;
     ex2.object<type>().~type();
   }
@@ -901,9 +794,9 @@ protected:
 
   template <typename Obj>
   static const object_fns* object_fns_table(
-      typename enable_if<
+      enable_if_t<
         is_same<Obj, shared_target_executor>::value
-      >::type* = 0)
+      >* = 0)
   {
     static const object_fns fns =
     {
@@ -931,7 +824,7 @@ protected:
   template <typename Obj>
   static void move_object(any_executor_base& ex1, any_executor_base& ex2)
   {
-    new (&ex1.object_) Obj(BOOST_ASIO_MOVE_CAST(Obj)(ex2.object<Obj>()));
+    new (&ex1.object_) Obj(static_cast<Obj&&>(ex2.object<Obj>()));
     ex1.target_ = &ex1.object<Obj>();
     ex2.object<Obj>().~Obj();
   }
@@ -944,10 +837,10 @@ protected:
 
   template <typename Obj>
   static const object_fns* object_fns_table(
-      typename enable_if<
+      enable_if_t<
         !is_same<Obj, void>::value
           && !is_same<Obj, shared_target_executor>::value
-      >::type* = 0)
+      >* = 0)
   {
     static const object_fns fns =
     {
@@ -970,7 +863,7 @@ protected:
     const void* (*target_type)();
 #endif // !defined(BOOST_ASIO_NO_TYPEID)
     bool (*equal)(const any_executor_base&, const any_executor_base&);
-    void (*execute)(const any_executor_base&, BOOST_ASIO_MOVE_ARG(function));
+    void (*execute)(const any_executor_base&, function&&);
     void (*blocking_execute)(const any_executor_base&, function_view);
   };
 
@@ -993,35 +886,33 @@ protected:
   static bool equal_ex(const any_executor_base& ex1,
       const any_executor_base& ex2)
   {
-    return *ex1.target<Ex>() == *ex2.target<Ex>();
+    const Ex* p1 = ex1.target<Ex>();
+    const Ex* p2 = ex2.target<Ex>();
+    BOOST_ASIO_ASSUME(p1 != 0 && p2 != 0);
+    return *p1 == *p2;
   }
 
   template <typename Ex>
-  static void execute_ex(const any_executor_base& ex,
-      BOOST_ASIO_MOVE_ARG(function) f)
+  static void execute_ex(const any_executor_base& ex, function&& f)
   {
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    ex.target<Ex>()->execute(BOOST_ASIO_MOVE_CAST(function)(f));
-#else // defined(BOOST_ASIO_NO_DEPRECATED)
-    execution::execute(*ex.target<Ex>(), BOOST_ASIO_MOVE_CAST(function)(f));
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+    const Ex* p = ex.target<Ex>();
+    BOOST_ASIO_ASSUME(p != 0);
+    p->execute(static_cast<function&&>(f));
   }
 
   template <typename Ex>
   static void blocking_execute_ex(const any_executor_base& ex, function_view f)
   {
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    ex.target<Ex>()->execute(f);
-#else // defined(BOOST_ASIO_NO_DEPRECATED)
-    execution::execute(*ex.target<Ex>(), f);
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+    const Ex* p = ex.target<Ex>();
+    BOOST_ASIO_ASSUME(p != 0);
+    p->execute(f);
   }
 
   template <typename Ex>
   static const target_fns* target_fns_table(bool is_always_blocking,
-      typename enable_if<
+      enable_if_t<
         !is_same<Ex, void>::value
-      >::type* = 0)
+      >* = 0)
   {
     static const target_fns fns_with_execute =
     {
@@ -1055,10 +946,10 @@ protected:
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void*, const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         boost::asio::can_query<const Ex&, const Prop&>::value
           && is_same<typename Prop::polymorphic_query_result_type, void>::value
-      >::type*)
+      >*)
   {
     boost::asio::query(*static_cast<const Ex*>(ex),
         *static_cast<const Prop*>(prop));
@@ -1066,23 +957,23 @@ protected:
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void*, const void*, const void*,
-      typename enable_if<
+      enable_if_t<
         !boost::asio::can_query<const Ex&, const Prop&>::value
           && is_same<typename Prop::polymorphic_query_result_type, void>::value
-      >::type*)
+      >*)
   {
   }
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void* result, const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         boost::asio::can_query<const Ex&, const Prop&>::value
           && !is_same<typename Prop::polymorphic_query_result_type, void>::value
           && is_reference<typename Prop::polymorphic_query_result_type>::value
-      >::type*)
+      >*)
   {
-    *static_cast<typename remove_reference<
-      typename Prop::polymorphic_query_result_type>::type**>(result)
+    *static_cast<remove_reference_t<
+      typename Prop::polymorphic_query_result_type>**>(result)
         = &static_cast<typename Prop::polymorphic_query_result_type>(
             boost::asio::query(*static_cast<const Ex*>(ex),
               *static_cast<const Prop*>(prop)));
@@ -1090,22 +981,22 @@ protected:
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void*, const void*, const void*,
-      typename enable_if<
+      enable_if_t<
         !boost::asio::can_query<const Ex&, const Prop&>::value
           && !is_same<typename Prop::polymorphic_query_result_type, void>::value
           && is_reference<typename Prop::polymorphic_query_result_type>::value
-      >::type*)
+      >*)
   {
     std::terminate(); // Combination should not be possible.
   }
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void* result, const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         boost::asio::can_query<const Ex&, const Prop&>::value
           && !is_same<typename Prop::polymorphic_query_result_type, void>::value
           && is_scalar<typename Prop::polymorphic_query_result_type>::value
-      >::type*)
+      >*)
   {
     *static_cast<typename Prop::polymorphic_query_result_type*>(result)
       = static_cast<typename Prop::polymorphic_query_result_type>(
@@ -1115,11 +1006,11 @@ protected:
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void* result, const void*, const void*,
-      typename enable_if<
+      enable_if_t<
         !boost::asio::can_query<const Ex&, const Prop&>::value
           && !is_same<typename Prop::polymorphic_query_result_type, void>::value
           && is_scalar<typename Prop::polymorphic_query_result_type>::value
-      >::type*)
+      >*)
   {
     *static_cast<typename Prop::polymorphic_query_result_type*>(result)
       = typename Prop::polymorphic_query_result_type();
@@ -1127,12 +1018,12 @@ protected:
 
   template <typename Ex, class Prop>
   static void query_fn_non_void(void* result, const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         boost::asio::can_query<const Ex&, const Prop&>::value
           && !is_same<typename Prop::polymorphic_query_result_type, void>::value
           && !is_reference<typename Prop::polymorphic_query_result_type>::value
           && !is_scalar<typename Prop::polymorphic_query_result_type>::value
-      >::type*)
+      >*)
   {
     *static_cast<typename Prop::polymorphic_query_result_type**>(result)
       = new typename Prop::polymorphic_query_result_type(
@@ -1149,18 +1040,18 @@ protected:
 
   template <typename Ex, class Prop>
   static void query_fn_impl(void* result, const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         is_same<Ex, void>::value
-      >::type*)
+      >*)
   {
     query_fn_void(result, ex, prop);
   }
 
   template <typename Ex, class Prop>
   static void query_fn_impl(void* result, const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         !is_same<Ex, void>::value
-      >::type*)
+      >*)
   {
     query_fn_non_void<Ex, Prop>(result, ex, prop, 0);
   }
@@ -1173,9 +1064,9 @@ protected:
 
   template <typename Poly, typename Ex, class Prop>
   static Poly require_fn_impl(const void*, const void*,
-      typename enable_if<
+      enable_if_t<
         is_same<Ex, void>::value
-      >::type*)
+      >*)
   {
     bad_executor ex;
     boost::asio::detail::throw_exception(ex);
@@ -1184,9 +1075,9 @@ protected:
 
   template <typename Poly, typename Ex, class Prop>
   static Poly require_fn_impl(const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         !is_same<Ex, void>::value && Prop::is_requirable
-      >::type*)
+      >*)
   {
     return boost::asio::require(*static_cast<const Ex*>(ex),
         *static_cast<const Prop*>(prop));
@@ -1206,9 +1097,9 @@ protected:
 
   template <typename Poly, typename Ex, class Prop>
   static Poly prefer_fn_impl(const void*, const void*,
-      typename enable_if<
+      enable_if_t<
         is_same<Ex, void>::value
-      >::type*)
+      >*)
   {
     bad_executor ex;
     boost::asio::detail::throw_exception(ex);
@@ -1217,9 +1108,9 @@ protected:
 
   template <typename Poly, typename Ex, class Prop>
   static Poly prefer_fn_impl(const void* ex, const void* prop,
-      typename enable_if<
+      enable_if_t<
         !is_same<Ex, void>::value && Prop::is_preferable
-      >::type*)
+      >*)
   {
     return boost::asio::prefer(*static_cast<const Ex*>(ex),
         *static_cast<const Prop*>(prop));
@@ -1266,7 +1157,7 @@ private:
   void construct_object(Executor& ex, true_type)
   {
     object_fns_ = object_fns_table<Executor>();
-    target_ = new (&object_) Executor(BOOST_ASIO_MOVE_CAST(Executor)(ex));
+    target_ = new (&object_) Executor(static_cast<Executor&&>(ex));
   }
 
   template <typename Executor>
@@ -1275,26 +1166,26 @@ private:
     object_fns_ = object_fns_table<shared_target_executor>();
     Executor* p = 0;
     new (&object_) shared_target_executor(
-        BOOST_ASIO_MOVE_CAST(Executor)(ex), p);
+        static_cast<Executor&&>(ex), p);
     target_ = p;
   }
 
   template <typename Executor>
   void construct_object(std::nothrow_t,
-      Executor& ex, true_type) BOOST_ASIO_NOEXCEPT
+      Executor& ex, true_type) noexcept
   {
     object_fns_ = object_fns_table<Executor>();
-    target_ = new (&object_) Executor(BOOST_ASIO_MOVE_CAST(Executor)(ex));
+    target_ = new (&object_) Executor(static_cast<Executor&&>(ex));
   }
 
   template <typename Executor>
   void construct_object(std::nothrow_t,
-      Executor& ex, false_type) BOOST_ASIO_NOEXCEPT
+      Executor& ex, false_type) noexcept
   {
     object_fns_ = object_fns_table<shared_target_executor>();
     Executor* p = 0;
     new (&object_) shared_target_executor(
-        std::nothrow, BOOST_ASIO_MOVE_CAST(Executor)(ex), p);
+        std::nothrow, static_cast<Executor&&>(ex), p);
     target_ = p;
   }
 
@@ -1303,7 +1194,7 @@ private:
 
   typedef aligned_storage<
       sizeof(boost::asio::detail::shared_ptr<void>) + sizeof(void*),
-      alignment_of<boost::asio::detail::shared_ptr<void> >::value
+      alignment_of<boost::asio::detail::shared_ptr<void>>::value
     >::type object_type;
 
   object_type object_;
@@ -1320,8 +1211,7 @@ struct any_executor_context
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 template <typename Derived, typename Property>
-struct any_executor_context<Derived, Property,
-    typename enable_if<Property::value>::type>
+struct any_executor_context<Derived, Property, enable_if_t<Property::value>>
 {
   typename Property::query_result_type context() const
   {
@@ -1337,48 +1227,46 @@ template <>
 class any_executor<> : public detail::any_executor_base
 {
 public:
-  any_executor() BOOST_ASIO_NOEXCEPT
+  any_executor() noexcept
     : detail::any_executor_base()
   {
   }
 
-  any_executor(nullptr_t) BOOST_ASIO_NOEXCEPT
+  any_executor(nullptr_t) noexcept
     : detail::any_executor_base()
   {
   }
 
   template <typename Executor>
   any_executor(Executor ex,
-      typename enable_if<
-        conditional<
+      enable_if_t<
+        conditional_t<
           !is_same<Executor, any_executor>::value
             && !is_base_of<detail::any_executor_base, Executor>::value,
           is_executor<Executor>,
           false_type
-        >::type::value
-      >::type* = 0)
+        >::value
+      >* = 0)
     : detail::any_executor_base(
-        BOOST_ASIO_MOVE_CAST(Executor)(ex), false_type())
+        static_cast<Executor&&>(ex), false_type())
   {
   }
 
   template <typename Executor>
   any_executor(std::nothrow_t, Executor ex,
-      typename enable_if<
-        conditional<
+      enable_if_t<
+        conditional_t<
           !is_same<Executor, any_executor>::value
             && !is_base_of<detail::any_executor_base, Executor>::value,
           is_executor<Executor>,
           false_type
-        >::type::value
-      >::type* = 0) BOOST_ASIO_NOEXCEPT
+        >::value
+      >* = 0) noexcept
     : detail::any_executor_base(std::nothrow,
-        BOOST_ASIO_MOVE_CAST(Executor)(ex), false_type())
+        static_cast<Executor&&>(ex), false_type())
   {
   }
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
   template <typename... OtherSupportableProperties>
   any_executor(any_executor<OtherSupportableProperties...> other)
     : detail::any_executor_base(
@@ -1388,46 +1276,25 @@ public:
 
   template <typename... OtherSupportableProperties>
   any_executor(std::nothrow_t,
-      any_executor<OtherSupportableProperties...> other) BOOST_ASIO_NOEXCEPT
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other))
-  {
-  }
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-  template <typename U0, typename U1, typename U2, typename U3,
-      typename U4, typename U5, typename U6, typename U7>
-  any_executor(any_executor<U0, U1, U2, U3, U4, U5, U6, U7> other)
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other))
-  {
-  }
-
-  template <typename U0, typename U1, typename U2, typename U3,
-      typename U4, typename U5, typename U6, typename U7>
-  any_executor(std::nothrow_t,
-      any_executor<U0, U1, U2, U3, U4, U5, U6, U7> other) BOOST_ASIO_NOEXCEPT
+      any_executor<OtherSupportableProperties...> other) noexcept
     : detail::any_executor_base(
         static_cast<const detail::any_executor_base&>(other))
   {
   }
 
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-  any_executor(const any_executor& other) BOOST_ASIO_NOEXCEPT
+  any_executor(const any_executor& other) noexcept
     : detail::any_executor_base(
         static_cast<const detail::any_executor_base&>(other))
   {
   }
 
-  any_executor(std::nothrow_t, const any_executor& other) BOOST_ASIO_NOEXCEPT
+  any_executor(std::nothrow_t, const any_executor& other) noexcept
     : detail::any_executor_base(
         static_cast<const detail::any_executor_base&>(other))
   {
   }
 
-  any_executor& operator=(const any_executor& other) BOOST_ASIO_NOEXCEPT
+  any_executor& operator=(const any_executor& other) noexcept
   {
     if (this != &other)
     {
@@ -1437,29 +1304,27 @@ public:
     return *this;
   }
 
-  any_executor& operator=(nullptr_t p) BOOST_ASIO_NOEXCEPT
+  any_executor& operator=(nullptr_t p) noexcept
   {
     detail::any_executor_base::operator=(p);
     return *this;
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-
-  any_executor(any_executor&& other) BOOST_ASIO_NOEXCEPT
+  any_executor(any_executor&& other) noexcept
     : detail::any_executor_base(
         static_cast<any_executor_base&&>(
           static_cast<any_executor_base&>(other)))
   {
   }
 
-  any_executor(std::nothrow_t, any_executor&& other) BOOST_ASIO_NOEXCEPT
+  any_executor(std::nothrow_t, any_executor&& other) noexcept
     : detail::any_executor_base(
         static_cast<any_executor_base&&>(
           static_cast<any_executor_base&>(other)))
   {
   }
 
-  any_executor& operator=(any_executor&& other) BOOST_ASIO_NOEXCEPT
+  any_executor& operator=(any_executor&& other) noexcept
   {
     if (this != &other)
     {
@@ -1470,9 +1335,7 @@ public:
     return *this;
   }
 
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-  void swap(any_executor& other) BOOST_ASIO_NOEXCEPT
+  void swap(any_executor& other) noexcept
   {
     detail::any_executor_base::swap(
         static_cast<detail::any_executor_base&>(other));
@@ -1484,77 +1347,75 @@ public:
   using detail::any_executor_base::operator unspecified_bool_type;
   using detail::any_executor_base::operator!;
 
-  bool equality_helper(const any_executor& other) const BOOST_ASIO_NOEXCEPT
+  bool equality_helper(const any_executor& other) const noexcept
   {
     return any_executor_base::equality_helper(other);
   }
 
   template <typename AnyExecutor1, typename AnyExecutor2>
-  friend typename enable_if<
+  friend enable_if_t<
     is_base_of<any_executor, AnyExecutor1>::value
       || is_base_of<any_executor, AnyExecutor2>::value,
     bool
-  >::type operator==(const AnyExecutor1& a,
-      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  > operator==(const AnyExecutor1& a,
+      const AnyExecutor2& b) noexcept
   {
     return static_cast<const any_executor&>(a).equality_helper(b);
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator==(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  > operator==(const AnyExecutor& a, nullptr_t) noexcept
   {
     return !a;
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator==(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  > operator==(nullptr_t, const AnyExecutor& b) noexcept
   {
     return !b;
   }
 
   template <typename AnyExecutor1, typename AnyExecutor2>
-  friend typename enable_if<
+  friend enable_if_t<
     is_base_of<any_executor, AnyExecutor1>::value
       || is_base_of<any_executor, AnyExecutor2>::value,
     bool
-  >::type operator!=(const AnyExecutor1& a,
-      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  > operator!=(const AnyExecutor1& a,
+      const AnyExecutor2& b) noexcept
   {
     return !static_cast<const any_executor&>(a).equality_helper(b);
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator!=(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  > operator!=(const AnyExecutor& a, nullptr_t) noexcept
   {
     return !!a;
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator!=(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  > operator!=(nullptr_t, const AnyExecutor& b) noexcept
   {
     return !!b;
   }
 };
 
-inline void swap(any_executor<>& a, any_executor<>& b) BOOST_ASIO_NOEXCEPT
+inline void swap(any_executor<>& a, any_executor<>& b) noexcept
 {
   return a.swap(b);
 }
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 template <typename... SupportableProperties>
 class any_executor :
   public detail::any_executor_base,
@@ -1564,13 +1425,13 @@ class any_executor :
         0, void(SupportableProperties...)>::find_context_as_property>
 {
 public:
-  any_executor() BOOST_ASIO_NOEXCEPT
+  any_executor() noexcept
     : detail::any_executor_base(),
       prop_fns_(prop_fns_table<void>())
   {
   }
 
-  any_executor(nullptr_t) BOOST_ASIO_NOEXCEPT
+  any_executor(nullptr_t) noexcept
     : detail::any_executor_base(),
       prop_fns_(prop_fns_table<void>())
   {
@@ -1578,34 +1439,34 @@ public:
 
   template <typename Executor>
   any_executor(Executor ex,
-      typename enable_if<
-        conditional<
+      enable_if_t<
+        conditional_t<
           !is_same<Executor, any_executor>::value
             && !is_base_of<detail::any_executor_base, Executor>::value,
           detail::is_valid_target_executor<
             Executor, void(SupportableProperties...)>,
           false_type
-        >::type::value
-      >::type* = 0)
+        >::value
+      >* = 0)
     : detail::any_executor_base(
-        BOOST_ASIO_MOVE_CAST(Executor)(ex), false_type()),
+        static_cast<Executor&&>(ex), false_type()),
       prop_fns_(prop_fns_table<Executor>())
   {
   }
 
   template <typename Executor>
   any_executor(std::nothrow_t, Executor ex,
-      typename enable_if<
-        conditional<
+      enable_if_t<
+        conditional_t<
           !is_same<Executor, any_executor>::value
             && !is_base_of<detail::any_executor_base, Executor>::value,
           detail::is_valid_target_executor<
             Executor, void(SupportableProperties...)>,
           false_type
-        >::type::value
-      >::type* = 0) BOOST_ASIO_NOEXCEPT
+        >::value
+      >* = 0) noexcept
     : detail::any_executor_base(std::nothrow,
-        BOOST_ASIO_MOVE_CAST(Executor)(ex), false_type()),
+        static_cast<Executor&&>(ex), false_type()),
       prop_fns_(prop_fns_table<Executor>())
   {
     if (this->template target<void>() == 0)
@@ -1614,62 +1475,64 @@ public:
 
   template <typename... OtherSupportableProperties>
   any_executor(any_executor<OtherSupportableProperties...> other,
-      typename enable_if<
-        conditional<
+      enable_if_t<
+        conditional_t<
           !is_same<
             any_executor<OtherSupportableProperties...>,
             any_executor
           >::value,
           typename detail::supportable_properties<
             0, void(SupportableProperties...)>::template is_valid_target<
-              any_executor<OtherSupportableProperties...> >,
+              any_executor<OtherSupportableProperties...>>,
           false_type
-        >::type::value
-      >::type* = 0)
-    : detail::any_executor_base(BOOST_ASIO_MOVE_CAST(
-          any_executor<OtherSupportableProperties...>)(other), true_type()),
-      prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...> >())
+        >::value
+      >* = 0)
+    : detail::any_executor_base(
+        static_cast<any_executor<OtherSupportableProperties...>&&>(other),
+        true_type()),
+      prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...>>())
   {
   }
 
   template <typename... OtherSupportableProperties>
   any_executor(std::nothrow_t,
       any_executor<OtherSupportableProperties...> other,
-      typename enable_if<
-        conditional<
+      enable_if_t<
+        conditional_t<
           !is_same<
             any_executor<OtherSupportableProperties...>,
             any_executor
           >::value,
           typename detail::supportable_properties<
             0, void(SupportableProperties...)>::template is_valid_target<
-              any_executor<OtherSupportableProperties...> >,
+              any_executor<OtherSupportableProperties...>>,
           false_type
-        >::type::value
-      >::type* = 0) BOOST_ASIO_NOEXCEPT
-    : detail::any_executor_base(std::nothrow, BOOST_ASIO_MOVE_CAST(
-          any_executor<OtherSupportableProperties...>)(other), true_type()),
-      prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...> >())
+        >::value
+      >* = 0) noexcept
+    : detail::any_executor_base(std::nothrow,
+        static_cast<any_executor<OtherSupportableProperties...>&&>(other),
+        true_type()),
+      prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...>>())
   {
     if (this->template target<void>() == 0)
       prop_fns_ = prop_fns_table<void>();
   }
 
-  any_executor(const any_executor& other) BOOST_ASIO_NOEXCEPT
+  any_executor(const any_executor& other) noexcept
     : detail::any_executor_base(
         static_cast<const detail::any_executor_base&>(other)),
       prop_fns_(other.prop_fns_)
   {
   }
 
-  any_executor(std::nothrow_t, const any_executor& other) BOOST_ASIO_NOEXCEPT
+  any_executor(std::nothrow_t, const any_executor& other) noexcept
     : detail::any_executor_base(
         static_cast<const detail::any_executor_base&>(other)),
       prop_fns_(other.prop_fns_)
   {
   }
 
-  any_executor& operator=(const any_executor& other) BOOST_ASIO_NOEXCEPT
+  any_executor& operator=(const any_executor& other) noexcept
   {
     if (this != &other)
     {
@@ -1680,16 +1543,14 @@ public:
     return *this;
   }
 
-  any_executor& operator=(nullptr_t p) BOOST_ASIO_NOEXCEPT
+  any_executor& operator=(nullptr_t p) noexcept
   {
     prop_fns_ = prop_fns_table<void>();
     detail::any_executor_base::operator=(p);
     return *this;
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-
-  any_executor(any_executor&& other) BOOST_ASIO_NOEXCEPT
+  any_executor(any_executor&& other) noexcept
     : detail::any_executor_base(
         static_cast<any_executor_base&&>(
           static_cast<any_executor_base&>(other))),
@@ -1698,7 +1559,7 @@ public:
     other.prop_fns_ = prop_fns_table<void>();
   }
 
-  any_executor(std::nothrow_t, any_executor&& other) BOOST_ASIO_NOEXCEPT
+  any_executor(std::nothrow_t, any_executor&& other) noexcept
     : detail::any_executor_base(
         static_cast<any_executor_base&&>(
           static_cast<any_executor_base&>(other))),
@@ -1707,7 +1568,7 @@ public:
     other.prop_fns_ = prop_fns_table<void>();
   }
 
-  any_executor& operator=(any_executor&& other) BOOST_ASIO_NOEXCEPT
+  any_executor& operator=(any_executor&& other) noexcept
   {
     if (this != &other)
     {
@@ -1719,9 +1580,7 @@ public:
     return *this;
   }
 
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-  void swap(any_executor& other) BOOST_ASIO_NOEXCEPT
+  void swap(any_executor& other) noexcept
   {
     if (this != &other)
     {
@@ -1739,65 +1598,65 @@ public:
   using detail::any_executor_base::operator unspecified_bool_type;
   using detail::any_executor_base::operator!;
 
-  bool equality_helper(const any_executor& other) const BOOST_ASIO_NOEXCEPT
+  bool equality_helper(const any_executor& other) const noexcept
   {
     return any_executor_base::equality_helper(other);
   }
 
   template <typename AnyExecutor1, typename AnyExecutor2>
-  friend typename enable_if<
+  friend enable_if_t<
     is_base_of<any_executor, AnyExecutor1>::value
       || is_base_of<any_executor, AnyExecutor2>::value,
     bool
-  >::type operator==(const AnyExecutor1& a,
-      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  > operator==(const AnyExecutor1& a,
+      const AnyExecutor2& b) noexcept
   {
     return static_cast<const any_executor&>(a).equality_helper(b);
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator==(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  > operator==(const AnyExecutor& a, nullptr_t) noexcept
   {
     return !a;
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator==(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  > operator==(nullptr_t, const AnyExecutor& b) noexcept
   {
     return !b;
   }
 
   template <typename AnyExecutor1, typename AnyExecutor2>
-  friend typename enable_if<
+  friend enable_if_t<
     is_base_of<any_executor, AnyExecutor1>::value
       || is_base_of<any_executor, AnyExecutor2>::value,
     bool
-  >::type operator!=(const AnyExecutor1& a,
-      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  > operator!=(const AnyExecutor1& a,
+      const AnyExecutor2& b) noexcept
   {
     return !static_cast<const any_executor&>(a).equality_helper(b);
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator!=(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  > operator!=(const AnyExecutor& a, nullptr_t) noexcept
   {
     return !!a;
   }
 
   template <typename AnyExecutor>
-  friend typename enable_if<
+  friend enable_if_t<
     is_same<AnyExecutor, any_executor>::value,
     bool
-  >::type operator!=(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  > operator!=(nullptr_t, const AnyExecutor& b) noexcept
   {
     return !!b;
   }
@@ -1810,13 +1669,18 @@ public:
 
   template <typename Property>
   void query(const Property& p,
-      typename enable_if<
+      enable_if_t<
         is_same<
           typename find_convertible_property<Property>::query_result_type,
           void
         >::value
-      >::type* = 0) const
+      >* = 0) const
   {
+    if (!target_)
+    {
+      bad_executor ex;
+      boost::asio::detail::throw_exception(ex);
+    }
     typedef find_convertible_property<Property> found;
     prop_fns_[found::index].query(0, object_fns_->target(*this),
         &static_cast<const typename found::type&>(p));
@@ -1825,7 +1689,7 @@ public:
   template <typename Property>
   typename find_convertible_property<Property>::query_result_type
   query(const Property& p,
-      typename enable_if<
+      enable_if_t<
         !is_same<
           typename find_convertible_property<Property>::query_result_type,
           void
@@ -1834,11 +1698,15 @@ public:
         is_reference<
           typename find_convertible_property<Property>::query_result_type
         >::value
-      >::type* = 0) const
+      >* = 0) const
   {
+    if (!target_)
+    {
+      bad_executor ex;
+      boost::asio::detail::throw_exception(ex);
+    }
     typedef find_convertible_property<Property> found;
-    typename remove_reference<
-      typename found::query_result_type>::type* result = 0;
+    remove_reference_t<typename found::query_result_type>* result = 0;
     prop_fns_[found::index].query(&result, object_fns_->target(*this),
         &static_cast<const typename found::type&>(p));
     return *result;
@@ -1847,7 +1715,7 @@ public:
   template <typename Property>
   typename find_convertible_property<Property>::query_result_type
   query(const Property& p,
-      typename enable_if<
+      enable_if_t<
         !is_same<
           typename find_convertible_property<Property>::query_result_type,
           void
@@ -1856,8 +1724,13 @@ public:
         is_scalar<
           typename find_convertible_property<Property>::query_result_type
         >::value
-      >::type* = 0) const
+      >* = 0) const
   {
+    if (!target_)
+    {
+      bad_executor ex;
+      boost::asio::detail::throw_exception(ex);
+    }
     typedef find_convertible_property<Property> found;
     typename found::query_result_type result;
     prop_fns_[found::index].query(&result, object_fns_->target(*this),
@@ -1868,7 +1741,7 @@ public:
   template <typename Property>
   typename find_convertible_property<Property>::query_result_type
   query(const Property& p,
-      typename enable_if<
+      enable_if_t<
         !is_same<
           typename find_convertible_property<Property>::query_result_type,
           void
@@ -1881,8 +1754,13 @@ public:
         !is_scalar<
           typename find_convertible_property<Property>::query_result_type
         >::value
-      >::type* = 0) const
+      >* = 0) const
   {
+    if (!target_)
+    {
+      bad_executor ex;
+      boost::asio::detail::throw_exception(ex);
+    }
     typedef find_convertible_property<Property> found;
     typename found::query_result_type* result;
     prop_fns_[found::index].query(&result, object_fns_->target(*this),
@@ -1899,10 +1777,15 @@ public:
 
   template <typename Property>
   any_executor require(const Property& p,
-      typename enable_if<
+      enable_if_t<
         find_convertible_requirable_property<Property>::value
-      >::type* = 0) const
+      >* = 0) const
   {
+    if (!target_)
+    {
+      bad_executor ex;
+      boost::asio::detail::throw_exception(ex);
+    }
     typedef find_convertible_requirable_property<Property> found;
     return prop_fns_[found::index].require(object_fns_->target(*this),
         &static_cast<const typename found::type&>(p));
@@ -1916,10 +1799,15 @@ public:
 
   template <typename Property>
   any_executor prefer(const Property& p,
-      typename enable_if<
+      enable_if_t<
         find_convertible_preferable_property<Property>::value
-      >::type* = 0) const
+      >* = 0) const
   {
+    if (!target_)
+    {
+      bad_executor ex;
+      boost::asio::detail::throw_exception(ex);
+    }
     typedef find_convertible_preferable_property<Property> found;
     return prop_fns_[found::index].prefer(object_fns_->target(*this),
         &static_cast<const typename found::type&>(p));
@@ -1948,702 +1836,91 @@ public:
 
 template <typename... SupportableProperties>
 inline void swap(any_executor<SupportableProperties...>& a,
-    any_executor<SupportableProperties...>& b) BOOST_ASIO_NOEXCEPT
+    any_executor<SupportableProperties...>& b) noexcept
 {
   return a.swap(b);
 }
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS(n) \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_##n
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_1 \
-  {  \
-    &detail::any_executor_base::query_fn<Ex, T1>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T1>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T1> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_2 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_1, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T2>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T2>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T2> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_3 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_2, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T3>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T3>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T3> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_4 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_3, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T4>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T4>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T4> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_5 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_4, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T5>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T5>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T5> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_6 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_5, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T6>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T6>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T6> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_7 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_6, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T7>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T7>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T7> \
-  }
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_8 \
-  BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_7, \
-  { \
-    &detail::any_executor_base::query_fn<Ex, T8>, \
-    &detail::any_executor_base::require_fn<any_executor, Ex, T8>, \
-    &detail::any_executor_base::prefer_fn<any_executor, Ex, T8> \
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-
-# define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_MOVE_OPS \
-  any_executor(any_executor&& other) BOOST_ASIO_NOEXCEPT \
-    : detail::any_executor_base( \
-        static_cast<any_executor_base&&>( \
-          static_cast<any_executor_base&>(other))), \
-      prop_fns_(other.prop_fns_) \
-  { \
-    other.prop_fns_ = prop_fns_table<void>(); \
-  } \
-  \
-  any_executor(std::nothrow_t, any_executor&& other) BOOST_ASIO_NOEXCEPT \
-    : detail::any_executor_base( \
-        static_cast<any_executor_base&&>( \
-          static_cast<any_executor_base&>(other))), \
-      prop_fns_(other.prop_fns_) \
-  { \
-    other.prop_fns_ = prop_fns_table<void>(); \
-  } \
-  \
-  any_executor& operator=(any_executor&& other) BOOST_ASIO_NOEXCEPT \
-  { \
-    if (this != &other) \
-    { \
-      prop_fns_ = other.prop_fns_; \
-      detail::any_executor_base::operator=( \
-          static_cast<detail::any_executor_base&&>( \
-            static_cast<detail::any_executor_base&>(other))); \
-    } \
-    return *this; \
-  } \
-  /**/
-#else // defined(BOOST_ASIO_HAS_MOVE)
-
-# define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_MOVE_OPS
-
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_DEF(n) \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  class any_executor<BOOST_ASIO_VARIADIC_TARGS(n)> : \
-    public detail::any_executor_base, \
-    public detail::any_executor_context< \
-      any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>, \
-        typename detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::find_context_as_property> \
-  { \
-  public: \
-    any_executor() BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base(), \
-        prop_fns_(prop_fns_table<void>()) \
-    { \
-    } \
-    \
-    any_executor(nullptr_t) BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base(), \
-        prop_fns_(prop_fns_table<void>()) \
-    { \
-    } \
-    \
-    template <BOOST_ASIO_EXECUTION_EXECUTOR Executor> \
-    any_executor(Executor ex, \
-        typename enable_if< \
-          conditional< \
-            !is_same<Executor, any_executor>::value \
-              && !is_base_of<detail::any_executor_base, Executor>::value, \
-            detail::is_valid_target_executor< \
-              Executor, void(BOOST_ASIO_VARIADIC_TARGS(n))>, \
-            false_type \
-          >::type::value \
-        >::type* = 0) \
-      : detail::any_executor_base(BOOST_ASIO_MOVE_CAST( \
-            Executor)(ex), false_type()), \
-        prop_fns_(prop_fns_table<Executor>()) \
-    { \
-    } \
-    \
-    template <BOOST_ASIO_EXECUTION_EXECUTOR Executor> \
-    any_executor(std::nothrow_t, Executor ex, \
-        typename enable_if< \
-          conditional< \
-            !is_same<Executor, any_executor>::value \
-              && !is_base_of<detail::any_executor_base, Executor>::value, \
-            detail::is_valid_target_executor< \
-              Executor, void(BOOST_ASIO_VARIADIC_TARGS(n))>, \
-            false_type \
-          >::type::value \
-        >::type* = 0) BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base(std::nothrow, \
-          BOOST_ASIO_MOVE_CAST(Executor)(ex), false_type()), \
-        prop_fns_(prop_fns_table<Executor>()) \
-    { \
-      if (this->template target<void>() == 0) \
-        prop_fns_ = prop_fns_table<void>(); \
-    } \
-    \
-    any_executor(const any_executor& other) BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base( \
-          static_cast<const detail::any_executor_base&>(other)), \
-        prop_fns_(other.prop_fns_) \
-    { \
-    } \
-    \
-    any_executor(std::nothrow_t, \
-        const any_executor& other) BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base( \
-          static_cast<const detail::any_executor_base&>(other)), \
-        prop_fns_(other.prop_fns_) \
-    { \
-      if (this->template target<void>() == 0) \
-        prop_fns_ = prop_fns_table<void>(); \
-    } \
-    \
-    any_executor(any_executor<> other) \
-      : detail::any_executor_base(BOOST_ASIO_MOVE_CAST( \
-            any_executor<>)(other), true_type()), \
-        prop_fns_(prop_fns_table<any_executor<> >()) \
-    { \
-    } \
-    \
-    any_executor(std::nothrow_t, any_executor<> other) BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base(std::nothrow, \
-          BOOST_ASIO_MOVE_CAST(any_executor<>)(other), true_type()), \
-        prop_fns_(prop_fns_table<any_executor<> >()) \
-    { \
-      if (this->template target<void>() == 0) \
-        prop_fns_ = prop_fns_table<void>(); \
-    } \
-    \
-    template <typename OtherAnyExecutor> \
-    any_executor(OtherAnyExecutor other, \
-        typename enable_if< \
-          conditional< \
-            !is_same<OtherAnyExecutor, any_executor>::value \
-              && is_base_of<detail::any_executor_base, \
-                OtherAnyExecutor>::value, \
-            typename detail::supportable_properties< \
-              0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-                is_valid_target<OtherAnyExecutor>, \
-            false_type \
-          >::type::value \
-        >::type* = 0) \
-      : detail::any_executor_base(BOOST_ASIO_MOVE_CAST( \
-            OtherAnyExecutor)(other), true_type()), \
-        prop_fns_(prop_fns_table<OtherAnyExecutor>()) \
-    { \
-    } \
-    \
-    template <typename OtherAnyExecutor> \
-    any_executor(std::nothrow_t, OtherAnyExecutor other, \
-        typename enable_if< \
-          conditional< \
-            !is_same<OtherAnyExecutor, any_executor>::value \
-              && is_base_of<detail::any_executor_base, \
-                OtherAnyExecutor>::value, \
-            typename detail::supportable_properties< \
-              0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-                is_valid_target<OtherAnyExecutor>, \
-            false_type \
-          >::type::value \
-        >::type* = 0) BOOST_ASIO_NOEXCEPT \
-      : detail::any_executor_base(std::nothrow, \
-          BOOST_ASIO_MOVE_CAST(OtherAnyExecutor)(other), true_type()), \
-        prop_fns_(prop_fns_table<OtherAnyExecutor>()) \
-    { \
-      if (this->template target<void>() == 0) \
-        prop_fns_ = prop_fns_table<void>(); \
-    } \
-    \
-    any_executor& operator=(const any_executor& other) BOOST_ASIO_NOEXCEPT \
-    { \
-      if (this != &other) \
-      { \
-        prop_fns_ = other.prop_fns_; \
-        detail::any_executor_base::operator=( \
-            static_cast<const detail::any_executor_base&>(other)); \
-      } \
-      return *this; \
-    } \
-    \
-    any_executor& operator=(nullptr_t p) BOOST_ASIO_NOEXCEPT \
-    { \
-      prop_fns_ = prop_fns_table<void>(); \
-      detail::any_executor_base::operator=(p); \
-      return *this; \
-    } \
-    \
-    BOOST_ASIO_PRIVATE_ANY_EXECUTOR_MOVE_OPS \
-    \
-    void swap(any_executor& other) BOOST_ASIO_NOEXCEPT \
-    { \
-      if (this != &other) \
-      { \
-        detail::any_executor_base::swap( \
-            static_cast<detail::any_executor_base&>(other)); \
-        const prop_fns<any_executor>* tmp_prop_fns = other.prop_fns_; \
-        other.prop_fns_ = prop_fns_; \
-        prop_fns_ = tmp_prop_fns; \
-      } \
-    } \
-    \
-    using detail::any_executor_base::execute; \
-    using detail::any_executor_base::target; \
-    using detail::any_executor_base::target_type; \
-    using detail::any_executor_base::operator unspecified_bool_type; \
-    using detail::any_executor_base::operator!; \
-    \
-    bool equality_helper(const any_executor& other) const BOOST_ASIO_NOEXCEPT \
-    { \
-      return any_executor_base::equality_helper(other); \
-    } \
-    \
-    template <typename AnyExecutor1, typename AnyExecutor2> \
-    friend typename enable_if< \
-      is_base_of<any_executor, AnyExecutor1>::value \
-        || is_base_of<any_executor, AnyExecutor2>::value, \
-      bool \
-    >::type operator==(const AnyExecutor1& a, \
-        const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT \
-    { \
-      return static_cast<const any_executor&>(a).equality_helper(b); \
-    } \
-    \
-    template <typename AnyExecutor> \
-    friend typename enable_if< \
-      is_same<AnyExecutor, any_executor>::value, \
-      bool \
-    >::type operator==(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT \
-    { \
-      return !a; \
-    } \
-    \
-    template <typename AnyExecutor> \
-    friend typename enable_if< \
-      is_same<AnyExecutor, any_executor>::value, \
-      bool \
-    >::type operator==(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT \
-    { \
-      return !b; \
-    } \
-    \
-    template <typename AnyExecutor1, typename AnyExecutor2> \
-    friend typename enable_if< \
-      is_base_of<any_executor, AnyExecutor1>::value \
-        || is_base_of<any_executor, AnyExecutor2>::value, \
-      bool \
-    >::type operator!=(const AnyExecutor1& a, \
-        const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT \
-    { \
-      return !static_cast<const any_executor&>(a).equality_helper(b); \
-    } \
-    \
-    template <typename AnyExecutor> \
-    friend typename enable_if< \
-      is_same<AnyExecutor, any_executor>::value, \
-      bool \
-    >::type operator!=(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT \
-    { \
-      return !!a; \
-    } \
-    \
-    template <typename AnyExecutor> \
-    friend typename enable_if< \
-      is_same<AnyExecutor, any_executor>::value, \
-      bool \
-    >::type operator!=(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT \
-    { \
-      return !!b; \
-    } \
-    \
-    template <typename T> \
-    struct find_convertible_property : \
-        detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-            find_convertible_property<T> {}; \
-    \
-    template <typename Property> \
-    void query(const Property& p, \
-        typename enable_if< \
-          is_same< \
-            typename find_convertible_property<Property>::query_result_type, \
-            void \
-          >::value \
-        >::type* = 0) const \
-    { \
-      typedef find_convertible_property<Property> found; \
-      prop_fns_[found::index].query(0, object_fns_->target(*this), \
-          &static_cast<const typename found::type&>(p)); \
-    } \
-    \
-    template <typename Property> \
-    typename find_convertible_property<Property>::query_result_type \
-    query(const Property& p, \
-        typename enable_if< \
-          !is_same< \
-            typename find_convertible_property<Property>::query_result_type, \
-            void \
-          >::value \
-          && \
-          is_reference< \
-            typename find_convertible_property<Property>::query_result_type \
-          >::value \
-        >::type* = 0) const \
-    { \
-      typedef find_convertible_property<Property> found; \
-      typename remove_reference< \
-        typename found::query_result_type>::type* result; \
-      prop_fns_[found::index].query(&result, object_fns_->target(*this), \
-          &static_cast<const typename found::type&>(p)); \
-      return *result; \
-    } \
-    \
-    template <typename Property> \
-    typename find_convertible_property<Property>::query_result_type \
-    query(const Property& p, \
-        typename enable_if< \
-          !is_same< \
-            typename find_convertible_property<Property>::query_result_type, \
-            void \
-          >::value \
-          && \
-          is_scalar< \
-            typename find_convertible_property<Property>::query_result_type \
-          >::value \
-        >::type* = 0) const \
-    { \
-      typedef find_convertible_property<Property> found; \
-      typename found::query_result_type result; \
-      prop_fns_[found::index].query(&result, object_fns_->target(*this), \
-          &static_cast<const typename found::type&>(p)); \
-      return result; \
-    } \
-    \
-    template <typename Property> \
-    typename find_convertible_property<Property>::query_result_type \
-    query(const Property& p, \
-        typename enable_if< \
-          !is_same< \
-            typename find_convertible_property<Property>::query_result_type, \
-            void \
-          >::value \
-          && \
-          !is_reference< \
-            typename find_convertible_property<Property>::query_result_type \
-          >::value \
-          && \
-          !is_scalar< \
-            typename find_convertible_property<Property>::query_result_type \
-          >::value \
-        >::type* = 0) const \
-    { \
-      typedef find_convertible_property<Property> found; \
-      typename found::query_result_type* result; \
-      prop_fns_[found::index].query(&result, object_fns_->target(*this), \
-          &static_cast<const typename found::type&>(p)); \
-      return *boost::asio::detail::scoped_ptr< \
-        typename found::query_result_type>(result); \
-    } \
-    \
-    template <typename T> \
-    struct find_convertible_requirable_property : \
-        detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-            find_convertible_requirable_property<T> {}; \
-    \
-    template <typename Property> \
-    any_executor require(const Property& p, \
-        typename enable_if< \
-          find_convertible_requirable_property<Property>::value \
-        >::type* = 0) const \
-    { \
-      typedef find_convertible_requirable_property<Property> found; \
-      return prop_fns_[found::index].require(object_fns_->target(*this), \
-          &static_cast<const typename found::type&>(p)); \
-    } \
-    \
-    template <typename T> \
-    struct find_convertible_preferable_property : \
-        detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-            find_convertible_preferable_property<T> {}; \
-    \
-    template <typename Property> \
-    any_executor prefer(const Property& p, \
-        typename enable_if< \
-          find_convertible_preferable_property<Property>::value \
-        >::type* = 0) const \
-    { \
-      typedef find_convertible_preferable_property<Property> found; \
-      return prop_fns_[found::index].prefer(object_fns_->target(*this), \
-          &static_cast<const typename found::type&>(p)); \
-    } \
-    \
-    template <typename Ex> \
-    static const prop_fns<any_executor>* prop_fns_table() \
-    { \
-      static const prop_fns<any_executor> fns[] = \
-      { \
-        BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS(n) \
-      }; \
-      return fns; \
-    } \
-    \
-    const prop_fns<any_executor>* prop_fns_; \
-    typedef detail::supportable_properties<0, \
-        void(BOOST_ASIO_VARIADIC_TARGS(n))> supportable_properties_type; \
-  }; \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline void swap(any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& a, \
-      any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& b) BOOST_ASIO_NOEXCEPT \
-  { \
-    return a.swap(b); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_ANY_EXECUTOR_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_DEF
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_MOVE_OPS
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_1
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_2
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_3
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_4
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_5
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_6
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_7
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PROP_FNS_8
-
-#endif // if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 } // namespace execution
 namespace traits {
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename... SupportableProperties>
-struct equality_comparable<execution::any_executor<SupportableProperties...> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-};
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <>
-struct equality_comparable<execution::any_executor<> >
+struct equality_comparable<execution::any_executor<SupportableProperties...>>
 {
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
+  static constexpr bool is_valid = true;
+  static constexpr bool is_noexcept = true;
 };
 
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_EQUALITY_COMPARABLE_DEF(n) \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct equality_comparable< \
-      execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)> > \
-  { \
-    static const bool is_valid = true; \
-    static const bool is_noexcept = true; \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(
-      BOOST_ASIO_PRIVATE_ANY_EXECUTOR_EQUALITY_COMPARABLE_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_EQUALITY_COMPARABLE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename F, typename... SupportableProperties>
 struct execute_member<execution::any_executor<SupportableProperties...>, F>
 {
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename F>
-struct execute_member<execution::any_executor<>, F>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
+  static constexpr bool is_valid = true;
+  static constexpr bool is_noexcept = false;
   typedef void result_type;
 };
 
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_EXECUTE_MEMBER_DEF(n) \
-  template <typename F, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct execute_member< \
-      execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>, F> \
-  { \
-    static const bool is_valid = true; \
-    static const bool is_noexcept = false; \
-    typedef void result_type; \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(
-      BOOST_ASIO_PRIVATE_ANY_EXECUTOR_EXECUTE_MEMBER_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_EXECUTE_MEMBER_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename Prop, typename... SupportableProperties>
 struct query_member<
     execution::any_executor<SupportableProperties...>, Prop,
-    typename enable_if<
+    enable_if_t<
       execution::detail::supportable_properties<
         0, void(SupportableProperties...)>::template
           find_convertible_property<Prop>::value
-    >::type>
+    >>
 {
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
+  static constexpr bool is_valid = true;
+  static constexpr bool is_noexcept = false;
   typedef typename execution::detail::supportable_properties<
       0, void(SupportableProperties...)>::template
         find_convertible_property<Prop>::query_result_type result_type;
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_QUERY_MEMBER_DEF(n) \
-  template <typename Prop, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct query_member< \
-      execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>, Prop, \
-      typename enable_if< \
-        execution::detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-            find_convertible_property<Prop>::value \
-    >::type> \
-  { \
-    static const bool is_valid = true; \
-    static const bool is_noexcept = false; \
-    typedef typename execution::detail::supportable_properties< \
-        0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-          find_convertible_property<Prop>::query_result_type result_type; \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_ANY_EXECUTOR_QUERY_MEMBER_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_QUERY_MEMBER_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename Prop, typename... SupportableProperties>
 struct require_member<
     execution::any_executor<SupportableProperties...>, Prop,
-    typename enable_if<
+    enable_if_t<
       execution::detail::supportable_properties<
         0, void(SupportableProperties...)>::template
           find_convertible_requirable_property<Prop>::value
-    >::type>
+    >>
 {
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
+  static constexpr bool is_valid = true;
+  static constexpr bool is_noexcept = false;
   typedef execution::any_executor<SupportableProperties...> result_type;
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_REQUIRE_MEMBER_DEF(n) \
-  template <typename Prop, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct require_member< \
-      execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>, Prop, \
-      typename enable_if< \
-        execution::detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-            find_convertible_requirable_property<Prop>::value \
-      >::type> \
-  { \
-    static const bool is_valid = true; \
-    static const bool is_noexcept = false; \
-    typedef execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)> result_type; \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(
-      BOOST_ASIO_PRIVATE_ANY_EXECUTOR_REQUIRE_MEMBER_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_REQUIRE_MEMBER_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename Prop, typename... SupportableProperties>
 struct prefer_member<
     execution::any_executor<SupportableProperties...>, Prop,
-    typename enable_if<
+    enable_if_t<
       execution::detail::supportable_properties<
         0, void(SupportableProperties...)>::template
           find_convertible_preferable_property<Prop>::value
-    >::type>
+    >>
 {
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
+  static constexpr bool is_valid = true;
+  static constexpr bool is_noexcept = false;
   typedef execution::any_executor<SupportableProperties...> result_type;
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#define BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PREFER_FREE_DEF(n) \
-  template <typename Prop, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct prefer_member< \
-      execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>, Prop, \
-      typename enable_if< \
-        execution::detail::supportable_properties< \
-          0, void(BOOST_ASIO_VARIADIC_TARGS(n))>::template \
-            find_convertible_preferable_property<Prop>::value \
-      >::type> \
-  { \
-    static const bool is_valid = true; \
-    static const bool is_noexcept = false; \
-    typedef execution::any_executor<BOOST_ASIO_VARIADIC_TARGS(n)> result_type; \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PREFER_FREE_DEF)
-#undef BOOST_ASIO_PRIVATE_ANY_EXECUTOR_PREFER_FREE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
 
 } // namespace traits