...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu , C++ Coding Standards

// ~~~~~~~~~~~~~~~ // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt ) #ifndef BOOST_ASIO_THREAD_POOL_HPP #define BOOST_ASIO_THREAD_POOL_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include < boost/asio/detail/config.hpp > #include < boost/asio/detail/atomic_count.hpp > #include < boost/asio/detail/scheduler.hpp > #include < boost/asio/detail/thread_group.hpp > #include < boost/asio/execution.hpp > #include < boost/asio/execution_context.hpp > #include < boost/asio/detail/push_options.hpp > namespace boost { namespace asio { namespace detail { struct thread_pool_bits static constexpr unsigned int blocking_never = 1; static constexpr unsigned int blocking_always = 2; static constexpr unsigned int blocking_mask = 3; static constexpr unsigned int relationship_continuation = 4; static constexpr unsigned int outstanding_work_tracked = 8; } // namespace detail /// A simple fixed-size thread pool. * The thread pool class is an execution context where functions are permitted * to run on one of a fixed number of threads. * @par Submitting tasks to the pool * To submit functions to the thread pool, use the @ref boost::asio::dispatch, * @ref boost::asio::post or @ref boost::asio::defer free functions. * For example: * @code void my_task() * ... * ... * // Launch the pool with four threads. * boost::asio::thread_pool pool(4); * // Submit a function to the pool. * boost::asio::post(pool, my_task); * // Submit a lambda object to the pool. * boost::asio::post(pool, * []() * { * ... * }); * // Wait for all tasks in the pool to complete. * pool.join(); @endcode class thread_pool : public execution_context public: template <typename Allocator, unsigned int Bits> class basic_executor_type; template <typename Allocator, unsigned int Bits> friend class basic_executor_type; /// Executor used to submit functions to a thread pool. typedef basic_executor_type<std::allocator<void>, 0> executor_type; #if !defined(BOOST_ASIO_NO_TS_EXECUTORS) /// Constructs a pool with an automatically determined number of threads. BOOST_ASIO_DECL thread_pool(); #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS) /// Constructs a pool with a specified number of threads. BOOST_ASIO_DECL thread_pool(std::size_t num_threads); /// Destructor. * Automatically stops and joins the pool, if not explicitly done beforehand. BOOST_ASIO_DECL ~thread_pool(); /// Obtains the executor associated with the pool. executor_type get_executor() noexcept; /// Obtains the executor associated with the pool. executor_type executor() noexcept; /// Stops the threads. * This function stops the threads as soon as possible. As a result of calling * @c stop(), pending function objects may be never be invoked. BOOST_ASIO_DECL void stop(); /// Attaches the current thread to the pool. * This function attaches the current thread to the pool so that it may be * used for executing submitted function objects. Blocks the calling thread * until the pool is stopped or joined and has no outstanding work. BOOST_ASIO_DECL void attach(); /// Joins the threads. * This function blocks until the threads in the pool have completed. If @c * stop() is not called prior to @c join(), the @c join() call will wait * until the pool has no more outstanding work. BOOST_ASIO_DECL void join(); /// Waits for threads to complete. * This function blocks until the threads in the pool have completed. If @c * stop() is not called prior to @c wait(), the @c wait() call will wait * until the pool has no more outstanding work. BOOST_ASIO_DECL void wait(); private: thread_pool(const thread_pool&) = delete; thread_pool& operator=(const thread_pool&) = delete; struct thread_function; // Helper function to create the underlying scheduler. BOOST_ASIO_DECL detail::scheduler& add_scheduler(detail::scheduler* s); // The underlying scheduler. detail::scheduler& scheduler_; // The threads in the pool. detail::thread_group threads_; // The current number of threads in the pool. detail::atomic_count num_threads_; /// Executor implementation type used to submit functions to a thread pool. template <typename Allocator, unsigned int Bits> class thread_pool::basic_executor_type : detail::thread_pool_bits public: /// Copy constructor. basic_executor_type(const basic_executor_type& other) noexcept : pool_(other.pool_), allocator_(other.allocator_), bits_(other.bits_) if (Bits & outstanding_work_tracked) if (pool_) pool_->scheduler_.work_started(); /// Move constructor. basic_executor_type(basic_executor_type&& other) noexcept : pool_(other.pool_), allocator_(static_cast<Allocator&&>(other.allocator_)), bits_(other.bits_) if (Bits & outstanding_work_tracked) other.pool_ = 0; /// Destructor. ~basic_executor_type() noexcept if (Bits & outstanding_work_tracked) if (pool_) pool_->scheduler_.work_finished(); /// Assignment operator. basic_executor_type& operator=(const basic_executor_type& other) noexcept; /// Move assignment operator. basic_executor_type& operator=(basic_executor_type&& other) noexcept; #if !defined(GENERATING_DOCUMENTATION) private: friend struct boost_asio_require_fn::impl; friend struct boost_asio_prefer_fn::impl; #endif // !defined(GENERATING_DOCUMENTATION) /// Obtain an executor with the @c blocking.possibly property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::blocking.possibly); @endcode constexpr basic_executor_type<Allocator, BOOST_ASIO_UNSPECIFIED(Bits & ~blocking_mask)> require(execution::blocking_t::possibly_t) const return basic_executor_type<Allocator, Bits & ~blocking_mask>( pool_, allocator_, bits_ & ~blocking_mask); /// Obtain an executor with the @c blocking.always property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::blocking.always); @endcode constexpr basic_executor_type<Allocator, BOOST_ASIO_UNSPECIFIED((Bits & ~blocking_mask) | blocking_always)> require(execution::blocking_t::always_t) const return basic_executor_type<Allocator, BOOST_ASIO_UNSPECIFIED((Bits & ~blocking_mask) | blocking_always)>( pool_, allocator_, bits_ & ~blocking_mask); /// Obtain an executor with the @c blocking.never property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::blocking.never); @endcode constexpr basic_executor_type<Allocator, BOOST_ASIO_UNSPECIFIED(Bits & ~blocking_mask)> require(execution::blocking_t::never_t) const return basic_executor_type<Allocator, Bits & ~blocking_mask>( pool_, allocator_, (bits_ & ~blocking_mask) | blocking_never); /// Obtain an executor with the @c relationship.fork property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::relationship.fork); @endcode constexpr basic_executor_type require(execution::relationship_t::fork_t) const return basic_executor_type(pool_, allocator_, bits_ & ~relationship_continuation); /// Obtain an executor with the @c relationship.continuation property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::relationship.continuation); @endcode constexpr basic_executor_type require( execution::relationship_t::continuation_t) const return basic_executor_type(pool_, allocator_, bits_ | relationship_continuation); /// Obtain an executor with the @c outstanding_work.tracked property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::outstanding_work.tracked); @endcode constexpr basic_executor_type<Allocator, BOOST_ASIO_UNSPECIFIED(Bits | outstanding_work_tracked)> require(execution::outstanding_work_t::tracked_t) const return basic_executor_type<Allocator, Bits | outstanding_work_tracked>( pool_, allocator_, bits_); /// Obtain an executor with the @c outstanding_work.untracked property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::outstanding_work.untracked); @endcode constexpr basic_executor_type<Allocator, BOOST_ASIO_UNSPECIFIED(Bits & ~outstanding_work_tracked)> require(execution::outstanding_work_t::untracked_t) const return basic_executor_type<Allocator, Bits & ~outstanding_work_tracked>( pool_, allocator_, bits_); /// Obtain an executor with the specified @c allocator property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::allocator(my_allocator)); @endcode template <typename OtherAllocator> constexpr basic_executor_type<OtherAllocator, Bits> require(execution::allocator_t<OtherAllocator> a) const return basic_executor_type<OtherAllocator, Bits>( pool_, a.value(), bits_); /// Obtain an executor with the default @c allocator property. * Do not call this function directly. It is intended for use with the * boost::asio::require customisation point. * For example: * @code auto ex1 = my_thread_pool.executor(); * auto ex2 = boost::asio::require(ex1, * boost::asio::execution::allocator); @endcode constexpr basic_executor_type<std::allocator<void>, Bits> require(execution::allocator_t<void>) const return basic_executor_type<std::allocator<void>, Bits>( pool_, std::allocator<void>(), bits_); #if !defined(GENERATING_DOCUMENTATION) private: friend struct boost_asio_query_fn::impl; friend struct boost::asio::execution::detail::mapping_t<0>; friend struct boost::asio::execution::detail::outstanding_work_t<0>; #endif // !defined(GENERATING_DOCUMENTATION) /// Query the current value of the @c mapping property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * if (boost::asio::query(ex, boost::asio::execution::mapping) * == boost::asio::execution::mapping.thread) * ... @endcode static constexpr execution::mapping_t query(execution::mapping_t) noexcept return execution::mapping.thread; /// Query the current value of the @c context property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * boost::asio::thread_pool& pool = boost::asio::query( * ex, boost::asio::execution::context); @endcode thread_pool& query(execution::context_t) const noexcept return *pool_; /// Query the current value of the @c blocking property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * if (boost::asio::query(ex, boost::asio::execution::blocking) * == boost::asio::execution::blocking.always) * ... @endcode constexpr execution::blocking_t query(execution::blocking_t) const noexcept return (bits_ & blocking_never) ? execution::blocking_t(execution::blocking.never) : ((Bits & blocking_always) ? execution::blocking_t(execution::blocking.always) : execution::blocking_t(execution::blocking.possibly)); /// Query the current value of the @c relationship property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * if (boost::asio::query(ex, boost::asio::execution::relationship) * == boost::asio::execution::relationship.continuation) * ... @endcode constexpr execution::relationship_t query( execution::relationship_t) const noexcept return (bits_ & relationship_continuation) ? execution::relationship_t(execution::relationship.continuation) : execution::relationship_t(execution::relationship.fork); /// Query the current value of the @c outstanding_work property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * if (boost::asio::query(ex, boost::asio::execution::outstanding_work) * == boost::asio::execution::outstanding_work.tracked) * ... @endcode static constexpr execution::outstanding_work_t query( execution::outstanding_work_t) noexcept return (Bits & outstanding_work_tracked) ? execution::outstanding_work_t(execution::outstanding_work.tracked) : execution::outstanding_work_t(execution::outstanding_work.untracked); /// Query the current value of the @c allocator property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * auto alloc = boost::asio::query(ex, * boost::asio::execution::allocator); @endcode template <typename OtherAllocator> constexpr Allocator query( execution::allocator_t<OtherAllocator>) const noexcept return allocator_; /// Query the current value of the @c allocator property. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * auto alloc = boost::asio::query(ex, * boost::asio::execution::allocator); @endcode constexpr Allocator query(execution::allocator_t<void>) const noexcept return allocator_; /// Query the occupancy (recommended number of work items) for the pool. * Do not call this function directly. It is intended for use with the * boost::asio::query customisation point. * For example: * @code auto ex = my_thread_pool.executor(); * std::size_t occupancy = boost::asio::query( * ex, boost::asio::execution::occupancy); @endcode std::size_t query(execution::occupancy_t) const noexcept return static_cast<std::size_t>(pool_->num_threads_); public: /// Determine whether the thread pool is running in the current thread. * @return @c true if the current thread is running the thread pool. Otherwise * returns @c false. bool running_in_this_thread() const noexcept; /// Compare two executors for equality. * Two executors are equal if they refer to the same underlying thread pool. friend bool operator==(const basic_executor_type& a, const basic_executor_type& b) noexcept return a.pool_ == b.pool_ && a.allocator_ == b.allocator_ && a.bits_ == b.bits_; /// Compare two executors for inequality. * Two executors are equal if they refer to the same underlying thread pool. friend bool operator!=(const basic_executor_type& a, const basic_executor_type& b) noexcept return a.pool_ != b.pool_ || a.allocator_ != b.allocator_ || a.bits_ != b.bits_; /// Execution function. template <typename Function> void execute(Function&& f) const this->do_execute(static_cast<Function&&>(f), integral_constant<bool, (Bits & blocking_always) != 0>()); public: #if !defined(BOOST_ASIO_NO_TS_EXECUTORS) /// Obtain the underlying execution context. thread_pool& context() const noexcept; /// Inform the thread pool that it has some outstanding work to do. * This function is used to inform the thread pool that some work has begun. * This ensures that the thread pool's join() function will not return while * the work is underway. void on_work_started() const noexcept; /// Inform the thread pool that some work is no longer outstanding. * This function is used to inform the thread pool that some work has * finished. Once the count of unfinished work reaches zero, the thread * pool's join() function is permitted to exit. void on_work_finished() const noexcept; /// Request the thread pool to invoke the given function object. * This function is used to ask the thread pool to execute the given function * object. If the current thread belongs to the pool, @c dispatch() executes * the function before returning. Otherwise, the function will be scheduled * to run on the thread pool. * @param f The function object to be called. The executor will make * a copy of the handler object as required. The function signature of the * function object must be: @code void function(); @endcode * @param a An allocator that may be used by the executor to allocate the * internal storage needed for function invocation. template <typename Function, typename OtherAllocator> void dispatch(Function&& f, const OtherAllocator& a) const; /// Request the thread pool to invoke the given function object. * This function is used to ask the thread pool to execute the given function * object. The function object will never be executed inside @c post(). * Instead, it will be scheduled to run on the thread pool. * @param f The function object to be called. The executor will make * a copy of the handler object as required. The function signature of the * function object must be: @code void function(); @endcode * @param a An allocator that may be used by the executor to allocate the * internal storage needed for function invocation. template <typename Function, typename OtherAllocator> void post(Function&& f, const OtherAllocator& a) const; /// Request the thread pool to invoke the given function object. * This function is used to ask the thread pool to execute the given function * object. The function object will never be executed inside @c defer(). * Instead, it will be scheduled to run on the thread pool. * If the current thread belongs to the thread pool, @c defer() will delay * scheduling the function object until the current thread returns control to * the pool. * @param f The function object to be called. The executor will make * a copy of the handler object as required. The function signature of the * function object must be: @code void function(); @endcode * @param a An allocator that may be used by the executor to allocate the * internal storage needed for function invocation. template <typename Function, typename OtherAllocator> void defer(Function&& f, const OtherAllocator& a) const; #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS) private: friend class thread_pool; template <typename, unsigned int> friend class basic_executor_type; // Constructor used by thread_pool::get_executor(). explicit basic_executor_type(thread_pool& p) noexcept : pool_(&p), allocator_(), bits_(0) if (Bits & outstanding_work_tracked) pool_->scheduler_.work_started(); // Constructor used by require(). basic_executor_type(thread_pool* p, const Allocator& a, unsigned int bits) noexcept : pool_(p), allocator_(a), bits_(bits) if (Bits & outstanding_work_tracked) if (pool_) pool_->scheduler_.work_started(); /// Execution helper implementation for possibly and never blocking. template <typename Function> void do_execute(Function&& f, false_type) const; /// Execution helper implementation for always blocking. template <typename Function> void do_execute(Function&& f, true_type) const; // The underlying thread pool. thread_pool* pool_; // The allocator used for execution functions. Allocator allocator_; // The runtime-switched properties of the thread pool executor. unsigned int bits_; #if !defined(GENERATING_DOCUMENTATION) namespace traits { #if !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT) template <typename Allocator, unsigned int Bits> struct equality_comparable< boost::asio::thread_pool::basic_executor_type<Allocator, Bits> static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; #endif // !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT) #if !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT) template <typename Allocator, unsigned int Bits, typename Function> struct execute_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, Function static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef void result_type; #endif // !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT) #if !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::blocking_t::possibly_t > : boost::asio::detail::thread_pool_bits static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef boost::asio::thread_pool::basic_executor_type< Allocator, Bits & ~blocking_mask> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::blocking_t::always_t > : boost::asio::detail::thread_pool_bits static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type<Allocator, (Bits & ~blocking_mask) | blocking_always> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::blocking_t::never_t > : boost::asio::detail::thread_pool_bits static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< Allocator, Bits & ~blocking_mask> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::relationship_t::fork_t static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< Allocator, Bits> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::relationship_t::continuation_t static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< Allocator, Bits> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::outstanding_work_t::tracked_t > : boost::asio::detail::thread_pool_bits static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< Allocator, Bits | outstanding_work_tracked> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::outstanding_work_t::untracked_t > : boost::asio::detail::thread_pool_bits static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< Allocator, Bits & ~outstanding_work_tracked> result_type; template <typename Allocator, unsigned int Bits> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::allocator_t<void> static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< std::allocator<void>, Bits> result_type; template <unsigned int Bits, typename Allocator, typename OtherAllocator> struct require_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::allocator_t<OtherAllocator> static constexpr bool is_valid = true; static constexpr bool is_noexcept = false; typedef boost::asio::thread_pool::basic_executor_type< OtherAllocator, Bits> result_type; #endif // !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) #if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT) template <typename Allocator, unsigned int Bits, typename Property> struct query_static_constexpr_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, Property, typename boost::asio::enable_if< boost::asio::is_convertible< Property, boost::asio::execution::outstanding_work_t >::value >::type > : boost::asio::detail::thread_pool_bits static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef boost::asio::execution::outstanding_work_t result_type; static constexpr result_type value() noexcept return (Bits & outstanding_work_tracked) ? execution::outstanding_work_t(execution::outstanding_work.tracked) : execution::outstanding_work_t(execution::outstanding_work.untracked); template <typename Allocator, unsigned int Bits, typename Property> struct query_static_constexpr_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, Property, typename boost::asio::enable_if< boost::asio::is_convertible< Property, boost::asio::execution::mapping_t >::value >::type static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef boost::asio::execution::mapping_t::thread_t result_type; static constexpr result_type value() noexcept return result_type(); #endif // !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT) #if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT) template <typename Allocator, unsigned int Bits, typename Property> struct query_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, Property, typename boost::asio::enable_if< boost::asio::is_convertible< Property, boost::asio::execution::blocking_t >::value >::type static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef boost::asio::execution::blocking_t result_type; template <typename Allocator, unsigned int Bits, typename Property> struct query_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, Property, typename boost::asio::enable_if< boost::asio::is_convertible< Property, boost::asio::execution::relationship_t >::value >::type static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef boost::asio::execution::relationship_t result_type; template <typename Allocator, unsigned int Bits> struct query_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::occupancy_t static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef std::size_t result_type; template <typename Allocator, unsigned int Bits> struct query_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::context_t static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef boost::asio::thread_pool& result_type; template <typename Allocator, unsigned int Bits> struct query_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::allocator_t<void> static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef Allocator result_type; template <typename Allocator, unsigned int Bits, typename OtherAllocator> struct query_member< boost::asio::thread_pool::basic_executor_type<Allocator, Bits>, boost::asio::execution::allocator_t<OtherAllocator> static constexpr bool is_valid = true; static constexpr bool is_noexcept = true; typedef Allocator result_type; #endif // !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT) } // namespace traits namespace execution { template <> struct is_executor<thread_pool> : false_type } // namespace execution #endif // !defined(GENERATING_DOCUMENTATION) } // namespace asio } // namespace boost #include < boost/asio/detail/pop_options.hpp > #include < boost/asio/impl/thread_pool.hpp > #if defined(BOOST_ASIO_HEADER_ONLY) # include < boost/asio/impl/thread_pool.ipp > #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_THREAD_POOL_HPP