ceph/src/boost/boost/asio/execution/outstanding_work.hpp

   1 //
   2 // execution/outstanding_work.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 #ifndef BOOST_ASIO_EXECUTION_OUTSTANDING_WORK_HPP
  12 #define BOOST_ASIO_EXECUTION_OUTSTANDING_WORK_HPP
  13
  14 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  15 # pragma once
  16 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  17
  18 #include <boost/asio/detail/config.hpp>
  19 #include <boost/asio/detail/type_traits.hpp>
  20 #include <boost/asio/execution/executor.hpp>
  21 #include <boost/asio/execution/scheduler.hpp>
  22 #include <boost/asio/execution/sender.hpp>
  23 #include <boost/asio/is_applicable_property.hpp>
  24 #include <boost/asio/query.hpp>
  25 #include <boost/asio/traits/query_free.hpp>
  26 #include <boost/asio/traits/query_member.hpp>
  27 #include <boost/asio/traits/query_static_constexpr_member.hpp>
  28 #include <boost/asio/traits/static_query.hpp>
  29 #include <boost/asio/traits/static_require.hpp>
  30
  31 #include <boost/asio/detail/push_options.hpp>
  32
  33 namespace boost {
  34 namespace asio {
  35
  36 #if defined(GENERATING_DOCUMENTATION)
  37
  38 namespace execution {
  39
  40 /// A property to describe whether task submission is likely in the future.
  41 struct outstanding_work_t
  42 {
  43   /// The outstanding_work_t property applies to executors, senders, and
  44   /// schedulers.
  45   template <typename T>
  46   static constexpr bool is_applicable_property_v =
  47     is_executor_v<T> || is_sender_v<T> || is_scheduler_v<T>;
  48
  49   /// The top-level outstanding_work_t property cannot be required.
  50   static constexpr bool is_requirable = false;
  51
  52   /// The top-level outstanding_work_t property cannot be preferred.
  53   static constexpr bool is_preferable = false;
  54
  55   /// The type returned by queries against an @c any_executor.
  56   typedef outstanding_work_t polymorphic_query_result_type;
  57
  58   /// A sub-property that indicates that the executor does not represent likely
  59   /// future submission of a function object.
  60   struct untracked_t
  61   {
  62     /// The outstanding_work_t::untracked_t property applies to executors,
  63     /// senders, and schedulers.
  64     template <typename T>
  65     static constexpr bool is_applicable_property_v =
  66       is_executor_v<T> || is_sender_v<T> || is_scheduler_v<T>;
  67
  68     /// The outstanding_work_t::untracked_t property can be required.
  69     static constexpr bool is_requirable = true;
  70
  71     /// The outstanding_work_t::untracked_t property can be preferred.
  72     static constexpr bool is_preferable = true;
  73
  74     /// The type returned by queries against an @c any_executor.
  75     typedef outstanding_work_t polymorphic_query_result_type;
  76
  77     /// Default constructor.
  78     constexpr untracked_t();
  79
  80     /// Get the value associated with a property object.
  81     /**
  82      * @returns untracked_t();
  83      */
  84     static constexpr outstanding_work_t value();
  85   };
  86
  87   /// A sub-property that indicates that the executor represents likely
  88   /// future submission of a function object.
  89   struct tracked_t
  90   {
  91     /// The outstanding_work_t::untracked_t property applies to executors,
  92     /// senders, and schedulers.
  93     template <typename T>
  94     static constexpr bool is_applicable_property_v =
  95       is_executor_v<T> || is_sender_v<T> || is_scheduler_v<T>;
  96
  97     /// The outstanding_work_t::tracked_t property can be required.
  98     static constexpr bool is_requirable = true;
  99
 100     /// The outstanding_work_t::tracked_t property can be preferred.
 101     static constexpr bool is_preferable = true;
 102
 103     /// The type returned by queries against an @c any_executor.
 104     typedef outstanding_work_t polymorphic_query_result_type;
 105
 106     /// Default constructor.
 107     constexpr tracked_t();
 108
 109     /// Get the value associated with a property object.
 110     /**
 111      * @returns tracked_t();
 112      */
 113     static constexpr outstanding_work_t value();
 114   };
 115
 116   /// A special value used for accessing the outstanding_work_t::untracked_t
 117   /// property.
 118   static constexpr untracked_t untracked;
 119
 120   /// A special value used for accessing the outstanding_work_t::tracked_t
 121   /// property.
 122   static constexpr tracked_t tracked;
 123
 124   /// Default constructor.
 125   constexpr outstanding_work_t();
 126
 127   /// Construct from a sub-property value.
 128   constexpr outstanding_work_t(untracked_t);
 129
 130   /// Construct from a sub-property value.
 131   constexpr outstanding_work_t(tracked_t);
 132
 133   /// Compare property values for equality.
 134   friend constexpr bool operator==(
 135       const outstanding_work_t& a, const outstanding_work_t& b) noexcept;
 136
 137   /// Compare property values for inequality.
 138   friend constexpr bool operator!=(
 139       const outstanding_work_t& a, const outstanding_work_t& b) noexcept;
 140 };
 141
 142 /// A special value used for accessing the outstanding_work_t property.
 143 constexpr outstanding_work_t outstanding_work;
 144
 145 } // namespace execution
 146
 147 #else // defined(GENERATING_DOCUMENTATION)
 148
 149 namespace execution {
 150 namespace detail {
 151 namespace outstanding_work {
 152
 153 template <int I> struct untracked_t;
 154 template <int I> struct tracked_t;
 155
 156 } // namespace outstanding_work
 157
 158 template <int I = 0>
 159 struct outstanding_work_t
 160 {
 161 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 162   template <typename T>
 163   BOOST_ASIO_STATIC_CONSTEXPR(bool,
 164     is_applicable_property_v = is_executor<T>::value
 165       || is_sender<T>::value || is_scheduler<T>::value);
 166 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 167
 168   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = false);
 169   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_preferable = false);
 170   typedef outstanding_work_t polymorphic_query_result_type;
 171
 172   typedef detail::outstanding_work::untracked_t<I> untracked_t;
 173   typedef detail::outstanding_work::tracked_t<I> tracked_t;
 174
 175   BOOST_ASIO_CONSTEXPR outstanding_work_t()
 176     : value_(-1)
 177   {
 178   }
 179
 180   BOOST_ASIO_CONSTEXPR outstanding_work_t(untracked_t)
 181     : value_(0)
 182   {
 183   }
 184
 185   BOOST_ASIO_CONSTEXPR outstanding_work_t(tracked_t)
 186     : value_(1)
 187   {
 188   }
 189
 190 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 191   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 192   template <typename T>
 193   static BOOST_ASIO_CONSTEXPR
 194   typename traits::query_static_constexpr_member<
 195       T, outstanding_work_t>::result_type
 196   static_query()
 197     BOOST_ASIO_NOEXCEPT_IF((
 198       traits::query_static_constexpr_member<
 199         T, outstanding_work_t
 200       >::is_noexcept))
 201   {
 202     return traits::query_static_constexpr_member<
 203         T, outstanding_work_t>::value();
 204   }
 205
 206   template <typename T>
 207   static BOOST_ASIO_CONSTEXPR
 208   typename traits::static_query<T, untracked_t>::result_type
 209   static_query(
 210       typename enable_if<
 211         !traits::query_static_constexpr_member<
 212             T, outstanding_work_t>::is_valid
 213           && !traits::query_member<T, outstanding_work_t>::is_valid
 214           && traits::static_query<T, untracked_t>::is_valid
 215       >::type* = 0) BOOST_ASIO_NOEXCEPT
 216   {
 217     return traits::static_query<T, untracked_t>::value();
 218   }
 219
 220   template <typename T>
 221   static BOOST_ASIO_CONSTEXPR
 222   typename traits::static_query<T, tracked_t>::result_type
 223   static_query(
 224       typename enable_if<
 225         !traits::query_static_constexpr_member<
 226             T, outstanding_work_t>::is_valid
 227           && !traits::query_member<T, outstanding_work_t>::is_valid
 228           && !traits::static_query<T, untracked_t>::is_valid
 229           && traits::static_query<T, tracked_t>::is_valid
 230       >::type* = 0) BOOST_ASIO_NOEXCEPT
 231   {
 232     return traits::static_query<T, tracked_t>::value();
 233   }
 234
 235   template <typename E,
 236       typename T = decltype(outstanding_work_t::static_query<E>())>
 237   static BOOST_ASIO_CONSTEXPR const T static_query_v
 238     = outstanding_work_t::static_query<E>();
 239 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 240        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 241
 242   friend BOOST_ASIO_CONSTEXPR bool operator==(
 243       const outstanding_work_t& a, const outstanding_work_t& b)
 244   {
 245     return a.value_ == b.value_;
 246   }
 247
 248   friend BOOST_ASIO_CONSTEXPR bool operator!=(
 249       const outstanding_work_t& a, const outstanding_work_t& b)
 250   {
 251     return a.value_ != b.value_;
 252   }
 253
 254   struct convertible_from_outstanding_work_t
 255   {
 256     BOOST_ASIO_CONSTEXPR convertible_from_outstanding_work_t(outstanding_work_t)
 257     {
 258     }
 259   };
 260
 261   template <typename Executor>
 262   friend BOOST_ASIO_CONSTEXPR outstanding_work_t query(
 263       const Executor& ex, convertible_from_outstanding_work_t,
 264       typename enable_if<
 265         can_query<const Executor&, untracked_t>::value
 266       >::type* = 0)
 267 #if !defined(__clang__) // Clang crashes if noexcept is used here.
 268 #if defined(BOOST_ASIO_MSVC) // Visual C++ wants the type to be qualified.
 269     BOOST_ASIO_NOEXCEPT_IF((
 270       is_nothrow_query<const Executor&,
 271         outstanding_work_t<>::untracked_t>::value))
 272 #else // defined(BOOST_ASIO_MSVC)
 273     BOOST_ASIO_NOEXCEPT_IF((
 274       is_nothrow_query<const Executor&, untracked_t>::value))
 275 #endif // defined(BOOST_ASIO_MSVC)
 276 #endif // !defined(__clang__)
 277   {
 278     return boost::asio::query(ex, untracked_t());
 279   }
 280
 281   template <typename Executor>
 282   friend BOOST_ASIO_CONSTEXPR outstanding_work_t query(
 283       const Executor& ex, convertible_from_outstanding_work_t,
 284       typename enable_if<
 285         !can_query<const Executor&, untracked_t>::value
 286           && can_query<const Executor&, tracked_t>::value
 287       >::type* = 0)
 288 #if !defined(__clang__) // Clang crashes if noexcept is used here.
 289 #if defined(BOOST_ASIO_MSVC) // Visual C++ wants the type to be qualified.
 290     BOOST_ASIO_NOEXCEPT_IF((
 291       is_nothrow_query<const Executor&,
 292         outstanding_work_t<>::tracked_t>::value))
 293 #else // defined(BOOST_ASIO_MSVC)
 294     BOOST_ASIO_NOEXCEPT_IF((
 295       is_nothrow_query<const Executor&, tracked_t>::value))
 296 #endif // defined(BOOST_ASIO_MSVC)
 297 #endif // !defined(__clang__)
 298   {
 299     return boost::asio::query(ex, tracked_t());
 300   }
 301
 302   BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(untracked_t, untracked);
 303   BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(tracked_t, tracked);
 304
 305 #if !defined(BOOST_ASIO_HAS_CONSTEXPR)
 306   static const outstanding_work_t instance;
 307 #endif // !defined(BOOST_ASIO_HAS_CONSTEXPR)
 308
 309 private:
 310   int value_;
 311 };
 312
 313 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 314   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 315 template <int I> template <typename E, typename T>
 316 const T outstanding_work_t<I>::static_query_v;
 317 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 318        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 319
 320 #if !defined(BOOST_ASIO_HAS_CONSTEXPR)
 321 template <int I>
 322 const outstanding_work_t<I> outstanding_work_t<I>::instance;
 323 #endif
 324
 325 template <int I>
 326 const typename outstanding_work_t<I>::untracked_t
 327 outstanding_work_t<I>::untracked;
 328
 329 template <int I>
 330 const typename outstanding_work_t<I>::tracked_t
 331 outstanding_work_t<I>::tracked;
 332
 333 namespace outstanding_work {
 334
 335 template <int I = 0>
 336 struct untracked_t
 337 {
 338 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 339   template <typename T>
 340   BOOST_ASIO_STATIC_CONSTEXPR(bool,
 341     is_applicable_property_v = is_executor<T>::value
 342       || is_sender<T>::value || is_scheduler<T>::value);
 343 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 344
 345   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
 346   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_preferable = true);
 347   typedef outstanding_work_t<I> polymorphic_query_result_type;
 348
 349   BOOST_ASIO_CONSTEXPR untracked_t()
 350   {
 351   }
 352
 353 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 354   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 355   template <typename T>
 356   static BOOST_ASIO_CONSTEXPR
 357   typename traits::query_static_constexpr_member<T, untracked_t>::result_type
 358   static_query()
 359     BOOST_ASIO_NOEXCEPT_IF((
 360       traits::query_static_constexpr_member<T, untracked_t>::is_noexcept))
 361   {
 362     return traits::query_static_constexpr_member<T, untracked_t>::value();
 363   }
 364
 365   template <typename T>
 366   static BOOST_ASIO_CONSTEXPR untracked_t static_query(
 367       typename enable_if<
 368         !traits::query_static_constexpr_member<T, untracked_t>::is_valid
 369           && !traits::query_member<T, untracked_t>::is_valid
 370           && !traits::query_free<T, untracked_t>::is_valid
 371           && !can_query<T, tracked_t<I> >::value
 372       >::type* = 0) BOOST_ASIO_NOEXCEPT
 373   {
 374     return untracked_t();
 375   }
 376
 377   template <typename E, typename T = decltype(untracked_t::static_query<E>())>
 378   static BOOST_ASIO_CONSTEXPR const T static_query_v
 379     = untracked_t::static_query<E>();
 380 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 381        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 382
 383   static BOOST_ASIO_CONSTEXPR outstanding_work_t<I> value()
 384   {
 385     return untracked_t();
 386   }
 387
 388   friend BOOST_ASIO_CONSTEXPR bool operator==(
 389       const untracked_t&, const untracked_t&)
 390   {
 391     return true;
 392   }
 393
 394   friend BOOST_ASIO_CONSTEXPR bool operator!=(
 395       const untracked_t&, const untracked_t&)
 396   {
 397     return false;
 398   }
 399 };
 400
 401 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 402   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 403 template <int I> template <typename E, typename T>
 404 const T untracked_t<I>::static_query_v;
 405 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 406        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 407
 408 template <int I = 0>
 409 struct tracked_t
 410 {
 411 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 412   template <typename T>
 413   BOOST_ASIO_STATIC_CONSTEXPR(bool,
 414     is_applicable_property_v = is_executor<T>::value
 415       || is_sender<T>::value || is_scheduler<T>::value);
 416 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 417
 418   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
 419   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_preferable = true);
 420   typedef outstanding_work_t<I> polymorphic_query_result_type;
 421
 422   BOOST_ASIO_CONSTEXPR tracked_t()
 423   {
 424   }
 425
 426 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 427   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 428   template <typename T>
 429   static BOOST_ASIO_CONSTEXPR
 430   typename traits::query_static_constexpr_member<T, tracked_t>::result_type
 431   static_query()
 432     BOOST_ASIO_NOEXCEPT_IF((
 433       traits::query_static_constexpr_member<T, tracked_t>::is_noexcept))
 434   {
 435     return traits::query_static_constexpr_member<T, tracked_t>::value();
 436   }
 437
 438   template <typename E, typename T = decltype(tracked_t::static_query<E>())>
 439   static BOOST_ASIO_CONSTEXPR const T static_query_v
 440     = tracked_t::static_query<E>();
 441 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 442        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 443
 444   static BOOST_ASIO_CONSTEXPR outstanding_work_t<I> value()
 445   {
 446     return tracked_t();
 447   }
 448
 449   friend BOOST_ASIO_CONSTEXPR bool operator==(
 450       const tracked_t&, const tracked_t&)
 451   {
 452     return true;
 453   }
 454
 455   friend BOOST_ASIO_CONSTEXPR bool operator!=(
 456       const tracked_t&, const tracked_t&)
 457   {
 458     return false;
 459   }
 460 };
 461
 462 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 463   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 464 template <int I> template <typename E, typename T>
 465 const T tracked_t<I>::static_query_v;
 466 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 467        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 468
 469 } // namespace outstanding_work
 470 } // namespace detail
 471
 472 typedef detail::outstanding_work_t<> outstanding_work_t;
 473
 474 #if defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
 475 constexpr outstanding_work_t outstanding_work;
 476 #else // defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
 477 namespace { static const outstanding_work_t&
 478   outstanding_work = outstanding_work_t::instance; }
 479 #endif
 480
 481 } // namespace execution
 482
 483 #if !defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 484
 485 template <typename T>
 486 struct is_applicable_property<T, execution::outstanding_work_t>
 487   : integral_constant<bool,
 488       execution::is_executor<T>::value
 489         || execution::is_sender<T>::value
 490         || execution::is_scheduler<T>::value>
 491 {
 492 };
 493
 494 template <typename T>
 495 struct is_applicable_property<T, execution::outstanding_work_t::untracked_t>
 496   : integral_constant<bool,
 497       execution::is_executor<T>::value
 498         || execution::is_sender<T>::value
 499         || execution::is_scheduler<T>::value>
 500 {
 501 };
 502
 503 template <typename T>
 504 struct is_applicable_property<T, execution::outstanding_work_t::tracked_t>
 505   : integral_constant<bool,
 506       execution::is_executor<T>::value
 507         || execution::is_sender<T>::value
 508         || execution::is_scheduler<T>::value>
 509 {
 510 };
 511
 512 #endif // !defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 513
 514 namespace traits {
 515
 516 #if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
 517
 518 template <typename T>
 519 struct query_free_default<T, execution::outstanding_work_t,
 520   typename enable_if<
 521     can_query<T, execution::outstanding_work_t::untracked_t>::value
 522   >::type>
 523 {
 524   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 525   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
 526     (is_nothrow_query<T, execution::outstanding_work_t::untracked_t>::value));
 527
 528   typedef execution::outstanding_work_t result_type;
 529 };
 530
 531 template <typename T>
 532 struct query_free_default<T, execution::outstanding_work_t,
 533   typename enable_if<
 534     !can_query<T, execution::outstanding_work_t::untracked_t>::value
 535       && can_query<T, execution::outstanding_work_t::tracked_t>::value
 536   >::type>
 537 {
 538   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 539   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
 540     (is_nothrow_query<T, execution::outstanding_work_t::tracked_t>::value));
 541
 542   typedef execution::outstanding_work_t result_type;
 543 };
 544
 545 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
 546
 547 #if !defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
 548   || !defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 549
 550 template <typename T>
 551 struct static_query<T, execution::outstanding_work_t,
 552   typename enable_if<
 553     traits::query_static_constexpr_member<T,
 554       execution::outstanding_work_t>::is_valid
 555   >::type>
 556 {
 557   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 558   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 559
 560   typedef typename traits::query_static_constexpr_member<T,
 561     execution::outstanding_work_t>::result_type result_type;
 562
 563   static BOOST_ASIO_CONSTEXPR result_type value()
 564   {
 565     return traits::query_static_constexpr_member<T,
 566       execution::outstanding_work_t>::value();
 567   }
 568 };
 569
 570 template <typename T>
 571 struct static_query<T, execution::outstanding_work_t,
 572   typename enable_if<
 573     !traits::query_static_constexpr_member<T,
 574         execution::outstanding_work_t>::is_valid
 575       && !traits::query_member<T,
 576         execution::outstanding_work_t>::is_valid
 577       && traits::static_query<T,
 578         execution::outstanding_work_t::untracked_t>::is_valid
 579   >::type>
 580 {
 581   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 582   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 583
 584   typedef typename traits::static_query<T,
 585     execution::outstanding_work_t::untracked_t>::result_type result_type;
 586
 587   static BOOST_ASIO_CONSTEXPR result_type value()
 588   {
 589     return traits::static_query<T,
 590         execution::outstanding_work_t::untracked_t>::value();
 591   }
 592 };
 593
 594 template <typename T>
 595 struct static_query<T, execution::outstanding_work_t,
 596   typename enable_if<
 597     !traits::query_static_constexpr_member<T,
 598         execution::outstanding_work_t>::is_valid
 599       && !traits::query_member<T,
 600         execution::outstanding_work_t>::is_valid
 601       && !traits::static_query<T,
 602         execution::outstanding_work_t::untracked_t>::is_valid
 603       && traits::static_query<T,
 604         execution::outstanding_work_t::tracked_t>::is_valid
 605   >::type>
 606 {
 607   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 608   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 609
 610   typedef typename traits::static_query<T,
 611     execution::outstanding_work_t::tracked_t>::result_type result_type;
 612
 613   static BOOST_ASIO_CONSTEXPR result_type value()
 614   {
 615     return traits::static_query<T,
 616         execution::outstanding_work_t::tracked_t>::value();
 617   }
 618 };
 619
 620 template <typename T>
 621 struct static_query<T, execution::outstanding_work_t::untracked_t,
 622   typename enable_if<
 623     traits::query_static_constexpr_member<T,
 624       execution::outstanding_work_t::untracked_t>::is_valid
 625   >::type>
 626 {
 627   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 628   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 629
 630   typedef typename traits::query_static_constexpr_member<T,
 631     execution::outstanding_work_t::untracked_t>::result_type result_type;
 632
 633   static BOOST_ASIO_CONSTEXPR result_type value()
 634   {
 635     return traits::query_static_constexpr_member<T,
 636       execution::outstanding_work_t::untracked_t>::value();
 637   }
 638 };
 639
 640 template <typename T>
 641 struct static_query<T, execution::outstanding_work_t::untracked_t,
 642   typename enable_if<
 643     !traits::query_static_constexpr_member<T,
 644         execution::outstanding_work_t::untracked_t>::is_valid
 645       && !traits::query_member<T,
 646         execution::outstanding_work_t::untracked_t>::is_valid
 647       && !traits::query_free<T,
 648         execution::outstanding_work_t::untracked_t>::is_valid
 649       && !can_query<T, execution::outstanding_work_t::tracked_t>::value
 650   >::type>
 651 {
 652   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 653   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 654
 655   typedef execution::outstanding_work_t::untracked_t result_type;
 656
 657   static BOOST_ASIO_CONSTEXPR result_type value()
 658   {
 659     return result_type();
 660   }
 661 };
 662
 663 template <typename T>
 664 struct static_query<T, execution::outstanding_work_t::tracked_t,
 665   typename enable_if<
 666     traits::query_static_constexpr_member<T,
 667       execution::outstanding_work_t::tracked_t>::is_valid
 668   >::type>
 669 {
 670   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 671   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 672
 673   typedef typename traits::query_static_constexpr_member<T,
 674     execution::outstanding_work_t::tracked_t>::result_type result_type;
 675
 676   static BOOST_ASIO_CONSTEXPR result_type value()
 677   {
 678     return traits::query_static_constexpr_member<T,
 679       execution::outstanding_work_t::tracked_t>::value();
 680   }
 681 };
 682
 683 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
 684        //   || !defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 685
 686 #if !defined(BOOST_ASIO_HAS_DEDUCED_STATIC_REQUIRE_TRAIT)
 687
 688 template <typename T>
 689 struct static_require<T, execution::outstanding_work_t::untracked_t,
 690   typename enable_if<
 691     static_query<T, execution::outstanding_work_t::untracked_t>::is_valid
 692   >::type>
 693 {
 694   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid =
 695     (is_same<typename static_query<T,
 696       execution::outstanding_work_t::untracked_t>::result_type,
 697         execution::outstanding_work_t::untracked_t>::value));
 698 };
 699
 700 template <typename T>
 701 struct static_require<T, execution::outstanding_work_t::tracked_t,
 702   typename enable_if<
 703     static_query<T, execution::outstanding_work_t::tracked_t>::is_valid
 704   >::type>
 705 {
 706   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid =
 707     (is_same<typename static_query<T,
 708       execution::outstanding_work_t::tracked_t>::result_type,
 709         execution::outstanding_work_t::tracked_t>::value));
 710 };
 711
 712 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_STATIC_REQUIRE_TRAIT)
 713
 714 } // namespace traits
 715
 716 #endif // defined(GENERATING_DOCUMENTATION)
 717
 718 } // namespace asio
 719 } // namespace boost
 720
 721 #include <boost/asio/detail/pop_options.hpp>
 722
 723 #endif // BOOST_ASIO_EXECUTION_OUTSTANDING_WORK_HPP