| // (C) Copyright 2008-10 Anthony Williams |
| // (C) Copyright 2011-2015 Vicente J. Botet Escriba |
| // |
| // 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_THREAD_FUTURE_HPP |
| #define BOOST_THREAD_FUTURE_HPP |
| |
| #include <boost/thread/detail/config.hpp> |
| |
| // boost::thread::future requires exception handling |
| // due to boost::exception::exception_ptr dependency |
| |
| #ifndef BOOST_NO_EXCEPTIONS |
| |
| #include <boost/thread/condition_variable.hpp> |
| #include <boost/thread/detail/move.hpp> |
| #include <boost/thread/detail/invoker.hpp> |
| #include <boost/thread/detail/invoke.hpp> |
| #include <boost/thread/detail/is_convertible.hpp> |
| #include <boost/thread/exceptional_ptr.hpp> |
| #include <boost/thread/futures/future_error.hpp> |
| #include <boost/thread/futures/future_error_code.hpp> |
| #include <boost/thread/futures/future_status.hpp> |
| #include <boost/thread/futures/is_future_type.hpp> |
| #include <boost/thread/futures/launch.hpp> |
| #include <boost/thread/futures/wait_for_all.hpp> |
| #include <boost/thread/futures/wait_for_any.hpp> |
| #include <boost/thread/lock_algorithms.hpp> |
| #include <boost/thread/lock_types.hpp> |
| #include <boost/thread/mutex.hpp> |
| #include <boost/thread/thread_only.hpp> |
| #include <boost/thread/thread_time.hpp> |
| |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| #include <boost/optional.hpp> |
| #else |
| #include <boost/thread/csbl/memory/unique_ptr.hpp> |
| #endif |
| |
| #include <boost/assert.hpp> |
| #include <boost/bind.hpp> |
| #ifdef BOOST_THREAD_USES_CHRONO |
| #include <boost/chrono/system_clocks.hpp> |
| #endif |
| #include <boost/core/enable_if.hpp> |
| #include <boost/core/ref.hpp> |
| #include <boost/enable_shared_from_this.hpp> |
| #include <boost/exception_ptr.hpp> |
| #include <boost/function.hpp> |
| #include <boost/next_prior.hpp> |
| #include <boost/scoped_array.hpp> |
| #include <boost/shared_ptr.hpp> |
| #include <boost/throw_exception.hpp> |
| #include <boost/type_traits/conditional.hpp> |
| #include <boost/type_traits/decay.hpp> |
| #include <boost/type_traits/is_copy_constructible.hpp> |
| #include <boost/type_traits/is_fundamental.hpp> |
| #include <boost/type_traits/is_void.hpp> |
| #include <boost/utility/result_of.hpp> |
| |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| #include <boost/thread/detail/memory.hpp> |
| #include <boost/container/scoped_allocator.hpp> |
| #if ! defined BOOST_NO_CXX11_ALLOCATOR |
| #include <memory> |
| #endif |
| #endif |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY |
| #include <boost/thread/csbl/tuple.hpp> |
| #include <boost/thread/csbl/vector.hpp> |
| #endif |
| |
| #include <algorithm> |
| #include <list> |
| #include <vector> |
| #include <utility> |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE |
| #define BOOST_THREAD_FUTURE future |
| #else |
| #define BOOST_THREAD_FUTURE unique_future |
| #endif |
| |
| namespace boost |
| { |
| namespace detail |
| { |
| struct relocker |
| { |
| boost::unique_lock<boost::mutex>& lock_; |
| |
| relocker(boost::unique_lock<boost::mutex>& lk): |
| lock_(lk) |
| { |
| lock_.unlock(); |
| } |
| ~relocker() |
| { |
| if (! lock_.owns_lock()) { |
| lock_.lock(); |
| } |
| } |
| void lock() { |
| if (! lock_.owns_lock()) { |
| lock_.lock(); |
| } |
| } |
| private: |
| relocker& operator=(relocker const&); |
| }; |
| |
| struct shared_state_base : enable_shared_from_this<shared_state_base> |
| { |
| typedef std::list<boost::condition_variable_any*> waiter_list; |
| typedef waiter_list::iterator notify_when_ready_handle; |
| // This type should be only included conditionally if interruptions are allowed, but is included to maintain the same layout. |
| typedef shared_ptr<shared_state_base> continuation_ptr_type; |
| typedef std::vector<continuation_ptr_type> continuations_type; |
| |
| boost::exception_ptr exception; |
| bool done; |
| bool is_valid_; |
| bool is_deferred_; |
| bool is_constructed; |
| std::size_t cnt_; |
| launch policy_; |
| mutable boost::mutex mutex; |
| boost::condition_variable waiters; |
| waiter_list external_waiters; |
| boost::function<void()> callback; |
| // This declaration should be only included conditionally, but is included to maintain the same layout. |
| continuations_type continuations; |
| |
| // This declaration should be only included conditionally, but is included to maintain the same layout. |
| virtual void launch_continuation(boost::unique_lock<boost::mutex>&, shared_ptr<shared_state_base>) |
| { |
| } |
| |
| shared_state_base(): |
| done(false), |
| is_valid_(true), |
| is_deferred_(false), |
| is_constructed(false), |
| cnt_(0), |
| policy_(launch::none), |
| continuations() |
| {} |
| virtual ~shared_state_base() |
| { |
| BOOST_ASSERT(cnt_==0); |
| } |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>&) |
| {} |
| |
| bool valid(boost::unique_lock<boost::mutex>&) { return is_valid_; } |
| bool valid() { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| return valid(lk); |
| } |
| void invalidate(boost::unique_lock<boost::mutex>&) { is_valid_ = false; } |
| void invalidate() { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| invalidate(lk); |
| } |
| void validate(boost::unique_lock<boost::mutex>&) { is_valid_ = true; } |
| void validate() { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| validate(lk); |
| } |
| |
| void inc(boost::unique_lock<boost::mutex>&) { ++cnt_; } |
| void inc() { boost::unique_lock<boost::mutex> lk(this->mutex); inc(lk); } |
| |
| void dec(boost::unique_lock<boost::mutex>& lk) { |
| if (--cnt_ == 0) { |
| block_if_needed(lk); |
| } |
| } |
| void dec() { boost::unique_lock<boost::mutex> lk(this->mutex); dec(lk); } |
| |
| void set_deferred() |
| { |
| is_deferred_ = true; |
| policy_ = launch::deferred; |
| } |
| void set_async() |
| { |
| is_deferred_ = false; |
| policy_ = launch::async; |
| } |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| void set_executor() |
| { |
| is_deferred_ = false; |
| policy_ = launch::executor; |
| } |
| #endif |
| notify_when_ready_handle notify_when_ready(boost::condition_variable_any& cv) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| do_callback(lock); |
| return external_waiters.insert(external_waiters.end(),&cv); |
| } |
| |
| void unnotify_when_ready(notify_when_ready_handle it) |
| { |
| boost::lock_guard<boost::mutex> lock(this->mutex); |
| external_waiters.erase(it); |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| void do_continuation(boost::unique_lock<boost::mutex>& lock) |
| { |
| if (! continuations.empty()) { |
| continuations_type the_continuations = continuations; |
| continuations.clear(); |
| relocker rlk(lock); |
| for (continuations_type::iterator it = the_continuations.begin(); it != the_continuations.end(); ++it) { |
| boost::unique_lock<boost::mutex> cont_lock((*it)->mutex); |
| (*it)->launch_continuation(cont_lock, *it); |
| } |
| } |
| } |
| #else |
| void do_continuation(boost::unique_lock<boost::mutex>&) |
| { |
| } |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| virtual void set_continuation_ptr(continuation_ptr_type continuation, boost::unique_lock<boost::mutex>& lock) |
| { |
| continuations.push_back(continuation); |
| if (done) { |
| do_continuation(lock); |
| } |
| } |
| #endif |
| void mark_finished_internal(boost::unique_lock<boost::mutex>& lock) |
| { |
| done=true; |
| waiters.notify_all(); |
| for(waiter_list::const_iterator it=external_waiters.begin(), |
| end=external_waiters.end();it!=end;++it) |
| { |
| (*it)->notify_all(); |
| } |
| do_continuation(lock); |
| } |
| void make_ready() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| mark_finished_internal(lock); |
| } |
| |
| void do_callback(boost::unique_lock<boost::mutex>& lock) |
| { |
| if(callback && !done) |
| { |
| boost::function<void()> local_callback=callback; |
| relocker relock(lock); |
| local_callback(); |
| } |
| } |
| |
| virtual bool run_if_is_deferred() |
| { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| if (is_deferred_) |
| { |
| is_deferred_=false; |
| execute(lk); |
| return true; |
| } |
| else |
| return false; |
| } |
| virtual bool run_if_is_deferred_or_ready() |
| { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| if (is_deferred_) |
| { |
| is_deferred_=false; |
| execute(lk); |
| |
| return true; |
| } |
| else |
| return done; |
| } |
| void wait_internal(boost::unique_lock<boost::mutex> &lk, bool rethrow=true) |
| { |
| do_callback(lk); |
| if (is_deferred_) |
| { |
| is_deferred_=false; |
| execute(lk); |
| } |
| while(!done) |
| { |
| waiters.wait(lk); |
| } |
| if(rethrow && exception) |
| { |
| boost::rethrow_exception(exception); |
| } |
| } |
| |
| virtual void wait(boost::unique_lock<boost::mutex>& lock, bool rethrow=true) |
| { |
| wait_internal(lock, rethrow); |
| } |
| |
| void wait(bool rethrow=true) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| wait(lock, rethrow); |
| } |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| bool timed_wait_until(boost::system_time const& target_time) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| if (is_deferred_) |
| return false; |
| |
| do_callback(lock); |
| while(!done) |
| { |
| bool const success=waiters.timed_wait(lock,target_time); |
| if(!success && !done) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| #endif |
| #ifdef BOOST_THREAD_USES_CHRONO |
| |
| template <class Clock, class Duration> |
| future_status |
| wait_until(const chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| if (is_deferred_) |
| return future_status::deferred; |
| do_callback(lock); |
| while(!done) |
| { |
| cv_status const st=waiters.wait_until(lock,abs_time); |
| if(st==cv_status::timeout && !done) |
| { |
| return future_status::timeout; |
| } |
| } |
| return future_status::ready; |
| } |
| #endif |
| void mark_exceptional_finish_internal(boost::exception_ptr const& e, boost::unique_lock<boost::mutex>& lock) |
| { |
| exception=e; |
| mark_finished_internal(lock); |
| } |
| |
| void mark_exceptional_finish() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| mark_exceptional_finish_internal(boost::current_exception(), lock); |
| } |
| |
| void set_exception_at_thread_exit(exception_ptr e) |
| { |
| unique_lock<boost::mutex> lk(this->mutex); |
| if (has_value(lk)) |
| { |
| throw_exception(promise_already_satisfied()); |
| } |
| exception=e; |
| this->is_constructed = true; |
| detail::make_ready_at_thread_exit(shared_from_this()); |
| } |
| |
| bool has_value() const |
| { |
| boost::lock_guard<boost::mutex> lock(this->mutex); |
| return done && ! exception; |
| } |
| |
| bool has_value(unique_lock<boost::mutex>& ) const |
| { |
| return done && ! exception; |
| } |
| |
| bool has_exception() const |
| { |
| boost::lock_guard<boost::mutex> lock(this->mutex); |
| return done && exception; |
| } |
| |
| launch launch_policy(boost::unique_lock<boost::mutex>&) const |
| { |
| return policy_; |
| } |
| |
| future_state::state get_state(boost::unique_lock<boost::mutex>& lk) const |
| { |
| if(!done) |
| { |
| return future_state::waiting; |
| } |
| else |
| { |
| return future_state::ready; |
| } |
| } |
| future_state::state get_state() const |
| { |
| boost::lock_guard<boost::mutex> guard(this->mutex); |
| if(!done) |
| { |
| return future_state::waiting; |
| } |
| else |
| { |
| return future_state::ready; |
| } |
| } |
| |
| exception_ptr get_exception_ptr() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| wait_internal(lock, false); |
| return exception; |
| } |
| |
| template<typename F,typename U> |
| void set_wait_callback(F f,U* u) |
| { |
| boost::lock_guard<boost::mutex> lock(this->mutex); |
| callback=boost::bind(f,boost::ref(*u)); |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>&) {} |
| |
| private: |
| shared_state_base(shared_state_base const&); |
| shared_state_base& operator=(shared_state_base const&); |
| }; |
| |
| // Used to create stand-alone futures |
| template<typename T> |
| struct shared_state: |
| detail::shared_state_base |
| { |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| typedef boost::optional<T> storage_type; |
| #else |
| typedef boost::csbl::unique_ptr<T> storage_type; |
| #endif |
| #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES |
| typedef T const& source_reference_type; |
| typedef BOOST_THREAD_RV_REF(T) rvalue_source_type; |
| typedef T move_dest_type; |
| #elif defined BOOST_THREAD_USES_MOVE |
| typedef typename conditional<boost::is_fundamental<T>::value,T,T const&>::type source_reference_type; |
| typedef BOOST_THREAD_RV_REF(T) rvalue_source_type; |
| typedef T move_dest_type; |
| #else |
| typedef T& source_reference_type; |
| typedef typename conditional<boost::thread_detail::is_convertible<T&,BOOST_THREAD_RV_REF(T) >::value, BOOST_THREAD_RV_REF(T),T const&>::type rvalue_source_type; |
| typedef typename conditional<boost::thread_detail::is_convertible<T&,BOOST_THREAD_RV_REF(T) >::value, BOOST_THREAD_RV_REF(T),T>::type move_dest_type; |
| #endif |
| |
| typedef const T& shared_future_get_result_type; |
| |
| storage_type result; |
| |
| shared_state(): |
| result() |
| {} |
| |
| ~shared_state() |
| {} |
| |
| void mark_finished_with_result_internal(source_reference_type result_, boost::unique_lock<boost::mutex>& lock) |
| { |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| result = result_; |
| #else |
| result.reset(new T(result_)); |
| #endif |
| this->mark_finished_internal(lock); |
| } |
| |
| void mark_finished_with_result_internal(rvalue_source_type result_, boost::unique_lock<boost::mutex>& lock) |
| { |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| result = boost::move(result_); |
| #elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| result.reset(new T(boost::move(result_))); |
| #else |
| result.reset(new T(static_cast<rvalue_source_type>(result_))); |
| #endif |
| this->mark_finished_internal(lock); |
| } |
| |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template <class ...Args> |
| void mark_finished_with_result_internal(boost::unique_lock<boost::mutex>& lock, BOOST_THREAD_FWD_REF(Args)... args) |
| { |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| result.emplace(boost::forward<Args>(args)...); |
| #else |
| result.reset(new T(boost::forward<Args>(args)...)); |
| #endif |
| this->mark_finished_internal(lock); |
| } |
| #endif |
| |
| void mark_finished_with_result(source_reference_type result_) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| this->mark_finished_with_result_internal(result_, lock); |
| } |
| |
| void mark_finished_with_result(rvalue_source_type result_) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| |
| #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| mark_finished_with_result_internal(boost::move(result_), lock); |
| #else |
| mark_finished_with_result_internal(static_cast<rvalue_source_type>(result_), lock); |
| #endif |
| } |
| |
| storage_type& get_storage(boost::unique_lock<boost::mutex>& lk) |
| { |
| wait_internal(lk); |
| return result; |
| } |
| virtual move_dest_type get(boost::unique_lock<boost::mutex>& lk) |
| { |
| return boost::move(*get_storage(lk)); |
| } |
| move_dest_type get() |
| { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| return this->get(lk); |
| } |
| |
| virtual shared_future_get_result_type get_sh(boost::unique_lock<boost::mutex>& lk) |
| { |
| return *get_storage(lk); |
| } |
| shared_future_get_result_type get_sh() |
| { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| return this->get_sh(lk); |
| } |
| |
| void set_value_at_thread_exit(source_reference_type result_) |
| { |
| unique_lock<boost::mutex> lk(this->mutex); |
| if (this->has_value(lk)) |
| { |
| throw_exception(promise_already_satisfied()); |
| } |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| result = result_; |
| #else |
| result.reset(new T(result_)); |
| #endif |
| |
| this->is_constructed = true; |
| detail::make_ready_at_thread_exit(shared_from_this()); |
| } |
| void set_value_at_thread_exit(rvalue_source_type result_) |
| { |
| unique_lock<boost::mutex> lk(this->mutex); |
| if (this->has_value(lk)) |
| throw_exception(promise_already_satisfied()); |
| |
| #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| result = boost::move(result_); |
| #else |
| result.reset(new T(boost::move(result_))); |
| #endif |
| #else |
| #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL |
| result = boost::move(result_); |
| #else |
| result.reset(new T(static_cast<rvalue_source_type>(result_))); |
| #endif |
| #endif |
| this->is_constructed = true; |
| detail::make_ready_at_thread_exit(shared_from_this()); |
| } |
| |
| private: |
| shared_state(shared_state const&); |
| shared_state& operator=(shared_state const&); |
| }; |
| |
| template<typename T> |
| struct shared_state<T&>: |
| detail::shared_state_base |
| { |
| typedef T* storage_type; |
| typedef T& source_reference_type; |
| typedef T& move_dest_type; |
| typedef T& shared_future_get_result_type; |
| |
| T* result; |
| |
| shared_state(): |
| result(0) |
| {} |
| |
| ~shared_state() |
| { |
| } |
| |
| void mark_finished_with_result_internal(source_reference_type result_, boost::unique_lock<boost::mutex>& lock) |
| { |
| result= &result_; |
| mark_finished_internal(lock); |
| } |
| |
| void mark_finished_with_result(source_reference_type result_) |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| mark_finished_with_result_internal(result_, lock); |
| } |
| |
| virtual T& get(boost::unique_lock<boost::mutex>& lock) |
| { |
| wait_internal(lock); |
| return *result; |
| } |
| T& get() |
| { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| return get(lk); |
| } |
| |
| virtual T& get_sh(boost::unique_lock<boost::mutex>& lock) |
| { |
| wait_internal(lock); |
| return *result; |
| } |
| T& get_sh() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| return get_sh(lock); |
| } |
| |
| void set_value_at_thread_exit(T& result_) |
| { |
| unique_lock<boost::mutex> lk(this->mutex); |
| if (this->has_value(lk)) |
| throw_exception(promise_already_satisfied()); |
| result= &result_; |
| this->is_constructed = true; |
| detail::make_ready_at_thread_exit(shared_from_this()); |
| } |
| |
| private: |
| shared_state(shared_state const&); |
| shared_state& operator=(shared_state const&); |
| }; |
| |
| template<> |
| struct shared_state<void>: |
| detail::shared_state_base |
| { |
| typedef void shared_future_get_result_type; |
| typedef void move_dest_type; |
| |
| shared_state() |
| {} |
| |
| void mark_finished_with_result_internal(boost::unique_lock<boost::mutex>& lock) |
| { |
| mark_finished_internal(lock); |
| } |
| |
| void mark_finished_with_result() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| mark_finished_with_result_internal(lock); |
| } |
| |
| virtual void get(boost::unique_lock<boost::mutex>& lock) |
| { |
| this->wait_internal(lock); |
| } |
| void get() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| this->get(lock); |
| } |
| |
| virtual void get_sh(boost::unique_lock<boost::mutex>& lock) |
| { |
| this->wait_internal(lock); |
| } |
| void get_sh() |
| { |
| boost::unique_lock<boost::mutex> lock(this->mutex); |
| this->get_sh(lock); |
| } |
| |
| void set_value_at_thread_exit() |
| { |
| unique_lock<boost::mutex> lk(this->mutex); |
| if (this->has_value(lk)) |
| { |
| throw_exception(promise_already_satisfied()); |
| } |
| this->is_constructed = true; |
| detail::make_ready_at_thread_exit(shared_from_this()); |
| } |
| private: |
| shared_state(shared_state const&); |
| shared_state& operator=(shared_state const&); |
| }; |
| |
| ///////////////////////// |
| /// future_async_shared_state_base |
| ///////////////////////// |
| template<typename Rp> |
| struct future_async_shared_state_base: shared_state<Rp> |
| { |
| typedef shared_state<Rp> base_type; |
| protected: |
| boost::thread thr_; |
| void join() |
| { |
| if (thr_.joinable()) thr_.join(); |
| } |
| public: |
| future_async_shared_state_base() |
| { |
| this->set_async(); |
| } |
| |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>& lk) |
| { |
| this->wait(lk, false); |
| } |
| |
| ~future_async_shared_state_base() |
| { |
| join(); |
| } |
| |
| virtual void wait(boost::unique_lock<boost::mutex>& lk, bool rethrow) |
| { |
| { |
| relocker rlk(lk); |
| join(); |
| } |
| this->base_type::wait(lk, rethrow); |
| } |
| }; |
| |
| ///////////////////////// |
| /// future_async_shared_state |
| ///////////////////////// |
| template<typename Rp, typename Fp> |
| struct future_async_shared_state: future_async_shared_state_base<Rp> |
| { |
| future_async_shared_state() |
| { |
| } |
| |
| void init(BOOST_THREAD_FWD_REF(Fp) f) |
| { |
| shared_ptr<boost::detail::shared_state_base> that = this->shared_from_this(); |
| this->thr_ = thread(&future_async_shared_state::run, that, boost::forward<Fp>(f)); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_, BOOST_THREAD_FWD_REF(Fp) f) |
| { |
| future_async_shared_state* that = dynamic_cast<future_async_shared_state*>(that_.get()); |
| try |
| { |
| that->mark_finished_with_result(f()); |
| } |
| catch(...) |
| { |
| that->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| template<typename Fp> |
| struct future_async_shared_state<void, Fp>: public future_async_shared_state_base<void> |
| { |
| void init(BOOST_THREAD_FWD_REF(Fp) f) |
| { |
| this->thr_ = thread(&future_async_shared_state::run, this->shared_from_this(), boost::move(f)); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_, BOOST_THREAD_FWD_REF(Fp) f) |
| { |
| future_async_shared_state* that = dynamic_cast<future_async_shared_state*>(that_.get()); |
| try |
| { |
| f(); |
| that->mark_finished_with_result(); |
| } |
| catch(...) |
| { |
| that->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| template<typename Rp, typename Fp> |
| struct future_async_shared_state<Rp&, Fp>: future_async_shared_state_base<Rp&> |
| { |
| void init(BOOST_THREAD_FWD_REF(Fp) f) |
| { |
| this->thr_ = thread(&future_async_shared_state::run, this->shared_from_this(), boost::move(f)); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_, BOOST_THREAD_FWD_REF(Fp) f) |
| { |
| future_async_shared_state* that = dynamic_cast<future_async_shared_state*>(that_.get()); |
| try |
| { |
| that->mark_finished_with_result(f()); |
| } |
| catch(...) |
| { |
| that->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| ////////////////////////// |
| /// future_deferred_shared_state |
| ////////////////////////// |
| template<typename Rp, typename Fp> |
| struct future_deferred_shared_state: shared_state<Rp> |
| { |
| typedef shared_state<Rp> base_type; |
| Fp func_; |
| |
| public: |
| explicit future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f) |
| : func_(boost::move(f)) |
| { |
| this->set_deferred(); |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try |
| { |
| Fp local_fuct=boost::move(func_); |
| relocker relock(lck); |
| Rp res = local_fuct(); |
| relock.lock(); |
| this->mark_finished_with_result_internal(boost::move(res), lck); |
| } |
| catch (...) |
| { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| template<typename Rp, typename Fp> |
| struct future_deferred_shared_state<Rp&,Fp>: shared_state<Rp&> |
| { |
| typedef shared_state<Rp&> base_type; |
| Fp func_; |
| |
| public: |
| explicit future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f) |
| : func_(boost::move(f)) |
| { |
| this->set_deferred(); |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try |
| { |
| this->mark_finished_with_result_internal(func_(), lck); |
| } |
| catch (...) |
| { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| |
| template<typename Fp> |
| struct future_deferred_shared_state<void,Fp>: shared_state<void> |
| { |
| typedef shared_state<void> base_type; |
| Fp func_; |
| |
| public: |
| explicit future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f) |
| : func_(boost::move(f)) |
| { |
| this->set_deferred(); |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try |
| { |
| Fp local_fuct=boost::move(func_); |
| relocker relock(lck); |
| local_fuct(); |
| relock.lock(); |
| this->mark_finished_with_result_internal(lck); |
| } |
| catch (...) |
| { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| |
| class future_waiter |
| { |
| struct registered_waiter; |
| typedef std::vector<int>::size_type count_type; |
| |
| struct registered_waiter |
| { |
| boost::shared_ptr<detail::shared_state_base> future_; |
| detail::shared_state_base::notify_when_ready_handle handle; |
| count_type index; |
| |
| registered_waiter(boost::shared_ptr<detail::shared_state_base> const& a_future, |
| detail::shared_state_base::notify_when_ready_handle handle_, |
| count_type index_): |
| future_(a_future),handle(handle_),index(index_) |
| {} |
| }; |
| |
| struct all_futures_lock |
| { |
| #ifdef _MANAGED |
| typedef std::ptrdiff_t count_type_portable; |
| #else |
| typedef count_type count_type_portable; |
| #endif |
| count_type_portable count; |
| boost::scoped_array<boost::unique_lock<boost::mutex> > locks; |
| |
| all_futures_lock(std::vector<registered_waiter>& futures): |
| count(futures.size()),locks(new boost::unique_lock<boost::mutex>[count]) |
| { |
| for(count_type_portable i=0;i<count;++i) |
| { |
| locks[i]=BOOST_THREAD_MAKE_RV_REF(boost::unique_lock<boost::mutex>(futures[i].future_->mutex)); |
| } |
| } |
| |
| void lock() |
| { |
| boost::lock(locks.get(),locks.get()+count); |
| } |
| |
| void unlock() |
| { |
| for(count_type_portable i=0;i<count;++i) |
| { |
| locks[i].unlock(); |
| } |
| } |
| }; |
| |
| boost::condition_variable_any cv; |
| std::vector<registered_waiter> futures_; |
| count_type future_count; |
| |
| public: |
| future_waiter(): |
| future_count(0) |
| {} |
| |
| template<typename F> |
| void add(F& f) |
| { |
| if(f.future_) |
| { |
| registered_waiter waiter(f.future_,f.future_->notify_when_ready(cv),future_count); |
| try { |
| futures_.push_back(waiter); |
| } catch(...) { |
| f.future_->unnotify_when_ready(waiter.handle); |
| throw; |
| } |
| } |
| ++future_count; |
| } |
| |
| #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES |
| template<typename F1, typename... Fs> |
| void add(F1& f1, Fs&... fs) |
| { |
| add(f1); add(fs...); |
| } |
| #endif |
| |
| count_type wait() |
| { |
| all_futures_lock lk(futures_); |
| for(;;) |
| { |
| for(count_type i=0;i<futures_.size();++i) |
| { |
| if(futures_[i].future_->done) |
| { |
| return futures_[i].index; |
| } |
| } |
| cv.wait(lk); |
| } |
| } |
| |
| ~future_waiter() |
| { |
| for(count_type i=0;i<futures_.size();++i) |
| { |
| futures_[i].future_->unnotify_when_ready(futures_[i].handle); |
| } |
| } |
| }; |
| |
| } |
| |
| template <typename R> |
| class BOOST_THREAD_FUTURE; |
| |
| template <typename R> |
| class shared_future; |
| |
| template<typename T> |
| struct is_future_type<BOOST_THREAD_FUTURE<T> > : true_type |
| { |
| }; |
| |
| template<typename T> |
| struct is_future_type<shared_future<T> > : true_type |
| { |
| }; |
| |
| // template<typename Iterator> |
| // typename boost::disable_if<is_future_type<Iterator>,Iterator>::type wait_for_any(Iterator begin,Iterator end) |
| // { |
| // if(begin==end) |
| // return end; |
| // |
| // detail::future_waiter waiter; |
| // for(Iterator current=begin;current!=end;++current) |
| // { |
| // waiter.add(*current); |
| // } |
| // return boost::next(begin,waiter.wait()); |
| // } |
| |
| #ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES |
| template<typename F1,typename F2> |
| typename boost::enable_if<is_future_type<F1>,unsigned>::type wait_for_any(F1& f1,F2& f2) |
| { |
| detail::future_waiter waiter; |
| waiter.add(f1); |
| waiter.add(f2); |
| return waiter.wait(); |
| } |
| |
| template<typename F1,typename F2,typename F3> |
| unsigned wait_for_any(F1& f1,F2& f2,F3& f3) |
| { |
| detail::future_waiter waiter; |
| waiter.add(f1); |
| waiter.add(f2); |
| waiter.add(f3); |
| return waiter.wait(); |
| } |
| |
| template<typename F1,typename F2,typename F3,typename F4> |
| unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4) |
| { |
| detail::future_waiter waiter; |
| waiter.add(f1); |
| waiter.add(f2); |
| waiter.add(f3); |
| waiter.add(f4); |
| return waiter.wait(); |
| } |
| |
| template<typename F1,typename F2,typename F3,typename F4,typename F5> |
| unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4,F5& f5) |
| { |
| detail::future_waiter waiter; |
| waiter.add(f1); |
| waiter.add(f2); |
| waiter.add(f3); |
| waiter.add(f4); |
| waiter.add(f5); |
| return waiter.wait(); |
| } |
| #else |
| template<typename F1, typename... Fs> |
| typename boost::enable_if<is_future_type<F1>, unsigned>::type wait_for_any(F1& f1, Fs&... fs) |
| { |
| detail::future_waiter waiter; |
| waiter.add(f1, fs...); |
| return waiter.wait(); |
| } |
| #endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| |
| template <typename R> |
| class promise; |
| |
| template <typename R> |
| class packaged_task; |
| |
| namespace detail |
| { |
| /// Common implementation for all the futures independently of the return type |
| class base_future |
| { |
| public: |
| }; |
| /// Common implementation for future and shared_future. |
| template <typename R> |
| class basic_future : public base_future |
| { |
| protected: |
| public: |
| |
| typedef boost::shared_ptr<detail::shared_state<R> > future_ptr; |
| typedef typename detail::shared_state<R>::move_dest_type move_dest_type; |
| |
| static //BOOST_CONSTEXPR |
| future_ptr make_exceptional_future_ptr(exceptional_ptr const& ex) { |
| promise<R> p; |
| p.set_exception(ex.ptr_); |
| return p.get_future().future_; |
| } |
| |
| void set_exceptional_if_invalid() { |
| if (valid()) return; |
| promise<R> p; |
| p.set_exception(future_uninitialized()); |
| future_ = p.get_future().future_; |
| } |
| |
| future_ptr future_; |
| |
| basic_future(future_ptr a_future): |
| future_(a_future) |
| { |
| if (a_future) a_future->inc(); |
| } |
| |
| public: |
| typedef future_state::state state; |
| |
| BOOST_THREAD_MOVABLE_ONLY(basic_future) |
| basic_future(): future_() {} |
| |
| |
| //BOOST_CONSTEXPR |
| basic_future(exceptional_ptr const& ex) |
| : future_(make_exceptional_future_ptr(ex)) |
| { |
| future_->inc(); |
| } |
| |
| ~basic_future() { |
| if (future_) future_->dec(); |
| } |
| |
| basic_future(BOOST_THREAD_RV_REF(basic_future) other) BOOST_NOEXCEPT: |
| future_(BOOST_THREAD_RV(other).future_) |
| { |
| BOOST_THREAD_RV(other).future_.reset(); |
| } |
| basic_future& operator=(BOOST_THREAD_RV_REF(basic_future) other) BOOST_NOEXCEPT |
| { |
| if (this->future_) { |
| this->future_->dec(); |
| } |
| future_=BOOST_THREAD_RV(other).future_; |
| BOOST_THREAD_RV(other).future_.reset(); |
| return *this; |
| } |
| void swap(basic_future& that) BOOST_NOEXCEPT |
| { |
| future_.swap(that.future_); |
| } |
| // functions to check state, and wait for ready |
| state get_state(boost::unique_lock<boost::mutex>& lk) const |
| { |
| if(!future_) |
| { |
| return future_state::uninitialized; |
| } |
| return future_->get_state(lk); |
| } |
| state get_state() const |
| { |
| if(!future_) |
| { |
| return future_state::uninitialized; |
| } |
| return future_->get_state(); |
| } |
| |
| bool is_ready() const |
| { |
| return get_state()==future_state::ready; |
| } |
| |
| bool is_ready(boost::unique_lock<boost::mutex>& lk) const |
| { |
| return get_state(lk)==future_state::ready; |
| } |
| bool has_exception() const |
| { |
| return future_ && future_->has_exception(); |
| } |
| |
| bool has_value() const |
| { |
| return future_ && future_->has_value(); |
| } |
| |
| launch launch_policy(boost::unique_lock<boost::mutex>& lk) const |
| { |
| if ( future_ ) return future_->launch_policy(lk); |
| else return launch(launch::none); |
| } |
| |
| exception_ptr get_exception_ptr() |
| { |
| return future_ |
| ? future_->get_exception_ptr() |
| : exception_ptr(); |
| } |
| |
| bool valid() const BOOST_NOEXCEPT |
| { |
| return future_ != 0 && future_->valid(); |
| } |
| |
| void wait() const |
| { |
| if(!future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| future_->wait(false); |
| } |
| |
| typedef detail::shared_state_base::notify_when_ready_handle notify_when_ready_handle; |
| |
| boost::mutex& mutex() { |
| if(!future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| return future_->mutex; |
| }; |
| |
| notify_when_ready_handle notify_when_ready(boost::condition_variable_any& cv) |
| { |
| if(!future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| return future_->notify_when_ready(cv); |
| } |
| |
| void unnotify_when_ready(notify_when_ready_handle h) |
| { |
| if(!future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| return future_->unnotify_when_ready(h); |
| } |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename Duration> |
| bool timed_wait(Duration const& rel_time) const |
| { |
| return timed_wait_until(boost::get_system_time()+rel_time); |
| } |
| |
| bool timed_wait_until(boost::system_time const& abs_time) const |
| { |
| if(!future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| return future_->timed_wait_until(abs_time); |
| } |
| #endif |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| future_status |
| wait_for(const chrono::duration<Rep, Period>& rel_time) const |
| { |
| return wait_until(chrono::steady_clock::now() + rel_time); |
| |
| } |
| template <class Clock, class Duration> |
| future_status |
| wait_until(const chrono::time_point<Clock, Duration>& abs_time) const |
| { |
| if(!future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| return future_->wait_until(abs_time); |
| } |
| #endif |
| |
| }; |
| |
| } // detail |
| BOOST_THREAD_DCL_MOVABLE_BEG(R) detail::basic_future<R> BOOST_THREAD_DCL_MOVABLE_END |
| |
| namespace detail |
| { |
| #if (!defined _MSC_VER || _MSC_VER >= 1400) // _MSC_VER == 1400 on MSVC 2005 |
| template <class Rp, class Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_async_shared_state(BOOST_THREAD_FWD_REF(Fp) f); |
| |
| template <class Rp, class Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f); |
| #endif // #if (!defined _MSC_VER || _MSC_VER >= 1400) |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template<typename F, typename Rp, typename Fp> |
| struct future_deferred_continuation_shared_state; |
| template<typename F, typename Rp, typename Fp> |
| struct future_async_continuation_shared_state; |
| |
| template <class F, class Rp, class Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_async_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| |
| template <class F, class Rp, class Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_deferred_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP |
| template<typename F, typename Rp> |
| struct future_unwrap_shared_state; |
| template <class F, class Rp> |
| inline BOOST_THREAD_FUTURE<Rp> |
| make_future_unwrap_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f); |
| #endif |
| } |
| |
| template <typename R> |
| class BOOST_THREAD_FUTURE : public detail::basic_future<R> |
| { |
| private: |
| typedef detail::basic_future<R> base_type; |
| typedef typename base_type::future_ptr future_ptr; |
| |
| friend class shared_future<R>; |
| friend class promise<R>; |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template <typename, typename, typename> |
| friend struct detail::future_async_continuation_shared_state; |
| template <typename, typename, typename> |
| friend struct detail::future_deferred_continuation_shared_state; |
| |
| template <class F, class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_async_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| |
| template <class F, class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_deferred_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP |
| template<typename F, typename Rp> |
| friend struct detail::future_unwrap_shared_state; |
| template <class F, class Rp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_unwrap_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f); |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| template <class> friend class packaged_task; // todo check if this works in windows |
| #else |
| friend class packaged_task<R>; |
| #endif |
| friend class detail::future_waiter; |
| |
| template <class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_async_shared_state(BOOST_THREAD_FWD_REF(Fp) f); |
| |
| template <class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f); |
| |
| |
| typedef typename base_type::move_dest_type move_dest_type; |
| public: // when_all |
| |
| BOOST_THREAD_FUTURE(future_ptr a_future): |
| base_type(a_future) |
| { |
| } |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(BOOST_THREAD_FUTURE) |
| typedef future_state::state state; |
| typedef R value_type; // EXTENSION |
| |
| BOOST_CONSTEXPR BOOST_THREAD_FUTURE() {} |
| //BOOST_CONSTEXPR |
| BOOST_THREAD_FUTURE(exceptional_ptr const& ex): |
| base_type(ex) {} |
| |
| ~BOOST_THREAD_FUTURE() {} |
| |
| BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE) other) BOOST_NOEXCEPT: |
| base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))) |
| { |
| } |
| inline BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R> >) other); // EXTENSION |
| |
| explicit BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(shared_future<R>) other) : |
| base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))) |
| {} |
| |
| BOOST_THREAD_FUTURE& operator=(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE) other) BOOST_NOEXCEPT |
| { |
| this->base_type::operator=(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))); |
| return *this; |
| } |
| |
| shared_future<R> share() |
| { |
| return shared_future<R>(::boost::move(*this)); |
| } |
| |
| void swap(BOOST_THREAD_FUTURE& other) |
| { |
| static_cast<base_type*>(this)->swap(other); |
| } |
| |
| // todo this function must be private and friendship provided to the internal users. |
| void set_async() |
| { |
| this->future_->set_async(); |
| } |
| // todo this function must be private and friendship provided to the internal users. |
| void set_deferred() |
| { |
| this->future_->set_deferred(); |
| } |
| bool run_if_is_deferred() { |
| return this->future_->run_if_is_deferred(); |
| } |
| bool run_if_is_deferred_or_ready() { |
| return this->future_->run_if_is_deferred_or_ready(); |
| } |
| // retrieving the value |
| move_dest_type get() |
| { |
| if (this->future_ == 0) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| unique_lock<boost::mutex> lk(this->future_->mutex); |
| if (! this->future_->valid(lk)) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET |
| this->future_->invalidate(lk); |
| #endif |
| return this->future_->get(lk); |
| } |
| |
| template <typename R2> |
| typename boost::disable_if< is_void<R2>, move_dest_type>::type |
| get_or(BOOST_THREAD_RV_REF(R2) v) |
| { |
| |
| if (this->future_ == 0) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| unique_lock<boost::mutex> lk(this->future_->mutex); |
| if (! this->future_->valid(lk)) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| this->future_->wait(lk, false); |
| #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET |
| this->future_->invalidate(lk); |
| #endif |
| |
| if (this->future_->has_value(lk)) { |
| return this->future_->get(lk); |
| } |
| else { |
| return boost::move(v); |
| } |
| } |
| |
| template <typename R2> |
| typename boost::disable_if< is_void<R2>, move_dest_type>::type |
| get_or(R2 const& v) // EXTENSION |
| { |
| if (this->future_ == 0) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| unique_lock<boost::mutex> lk(this->future_->mutex); |
| if (! this->future_->valid(lk)) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| this->future_->wait(lk, false); |
| #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET |
| this->future_->invalidate(lk); |
| #endif |
| if (this->future_->has_value(lk)) { |
| return this->future_->get(lk); |
| } |
| else { |
| return v; |
| } |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template<typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE)>::type> |
| then(BOOST_THREAD_FWD_REF(F) func); // EXTENSION |
| template<typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE)>::type> |
| then(launch policy, BOOST_THREAD_FWD_REF(F) func); // EXTENSION |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template<typename Ex, typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE)>::type> |
| then(Ex& ex, BOOST_THREAD_FWD_REF(F) func); // EXTENSION |
| #endif |
| |
| template <typename R2> |
| inline typename boost::disable_if< is_void<R2>, BOOST_THREAD_FUTURE<R> >::type |
| fallback_to(BOOST_THREAD_RV_REF(R2) v); // EXTENSION |
| template <typename R2> |
| inline typename boost::disable_if< is_void<R2>, BOOST_THREAD_FUTURE<R> >::type |
| fallback_to(R2 const& v); // EXTENSION |
| |
| #endif |
| |
| }; |
| |
| BOOST_THREAD_DCL_MOVABLE_BEG(T) BOOST_THREAD_FUTURE<T> BOOST_THREAD_DCL_MOVABLE_END |
| |
| template <typename R2> |
| class BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> > : public detail::basic_future<BOOST_THREAD_FUTURE<R2> > |
| { |
| typedef BOOST_THREAD_FUTURE<R2> R; |
| |
| private: |
| typedef detail::basic_future<R> base_type; |
| typedef typename base_type::future_ptr future_ptr; |
| |
| friend class shared_future<R>; |
| friend class promise<R>; |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template <typename, typename, typename> |
| friend struct detail::future_async_continuation_shared_state; |
| template <typename, typename, typename> |
| friend struct detail::future_deferred_continuation_shared_state; |
| |
| template <class F, class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_async_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| |
| template <class F, class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_deferred_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP |
| template<typename F, typename Rp> |
| friend struct detail::future_unwrap_shared_state; |
| template <class F, class Rp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_unwrap_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f); |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| template <class> friend class packaged_task; // todo check if this works in windows |
| #else |
| friend class packaged_task<R>; |
| #endif |
| friend class detail::future_waiter; |
| |
| template <class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_async_shared_state(BOOST_THREAD_FWD_REF(Fp) f); |
| |
| template <class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f); |
| |
| typedef typename base_type::move_dest_type move_dest_type; |
| |
| BOOST_THREAD_FUTURE(future_ptr a_future): |
| base_type(a_future) |
| { |
| } |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(BOOST_THREAD_FUTURE) |
| typedef future_state::state state; |
| typedef R value_type; // EXTENSION |
| |
| BOOST_CONSTEXPR BOOST_THREAD_FUTURE() {} |
| //BOOST_CONSTEXPR |
| BOOST_THREAD_FUTURE(exceptional_ptr const& ex): |
| base_type(ex) {} |
| |
| ~BOOST_THREAD_FUTURE() {} |
| |
| BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE) other) BOOST_NOEXCEPT: |
| base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))) |
| { |
| } |
| |
| BOOST_THREAD_FUTURE& operator=(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE) other) BOOST_NOEXCEPT |
| { |
| this->base_type::operator=(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))); |
| return *this; |
| } |
| |
| shared_future<R> share() |
| { |
| return shared_future<R>(::boost::move(*this)); |
| } |
| |
| void swap(BOOST_THREAD_FUTURE& other) |
| { |
| static_cast<base_type*>(this)->swap(other); |
| } |
| |
| // todo this function must be private and friendship provided to the internal users. |
| void set_async() |
| { |
| this->future_->set_async(); |
| } |
| // todo this function must be private and friendship provided to the internal users. |
| void set_deferred() |
| { |
| this->future_->set_deferred(); |
| } |
| bool run_if_is_deferred() { |
| return this->future_->run_if_is_deferred(); |
| } |
| bool run_if_is_deferred_or_ready() { |
| return this->future_->run_if_is_deferred_or_ready(); |
| } |
| // retrieving the value |
| move_dest_type get() |
| { |
| if (this->future_ == 0) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| unique_lock<boost::mutex> lk(this->future_->mutex); |
| if (! this->future_->valid(lk)) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET |
| this->future_->invalidate(lk); |
| #endif |
| return this->future_->get(lk); |
| } |
| move_dest_type get_or(BOOST_THREAD_RV_REF(R) v) // EXTENSION |
| { |
| if (this->future_ == 0) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| unique_lock<boost::mutex> lk(this->future_->mutex); |
| if (! this->future_->valid(lk)) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| this->future_->wait(lk, false); |
| #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET |
| this->future_->invalidate(lk); |
| #endif |
| if (this->future_->has_value(lk)) return this->future_->get(lk); |
| else return boost::move(v); |
| } |
| |
| move_dest_type get_or(R const& v) // EXTENSION |
| { |
| if (this->future_ == 0) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| unique_lock<boost::mutex> lk(this->future_->mutex); |
| if (! this->future_->valid(lk)) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| this->future_->wait(lk, false); |
| #ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET |
| this->future_->invalidate(lk); |
| #endif |
| if (this->future_->has_value(lk)) return this->future_->get(lk); |
| else return v; |
| } |
| |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template<typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE)>::type> |
| then(BOOST_THREAD_FWD_REF(F) func); // EXTENSION |
| template<typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE)>::type> |
| then(launch policy, BOOST_THREAD_FWD_REF(F) func); // EXTENSION |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template<typename Ex, typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE)>::type> |
| then(Ex &ex, BOOST_THREAD_FWD_REF(F) func); // EXTENSION |
| #endif |
| #endif |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP |
| inline |
| BOOST_THREAD_FUTURE<R2> |
| unwrap(); // EXTENSION |
| #endif |
| |
| }; |
| |
| template <typename R> |
| class shared_future : public detail::basic_future<R> |
| { |
| typedef detail::basic_future<R> base_type; |
| typedef typename base_type::future_ptr future_ptr; |
| |
| friend class detail::future_waiter; |
| friend class promise<R>; |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template <typename, typename, typename> |
| friend struct detail::future_async_continuation_shared_state; |
| template <typename, typename, typename> |
| friend struct detail::future_deferred_continuation_shared_state; |
| |
| template <class F, class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_async_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| |
| template <class F, class Rp, class Fp> |
| friend BOOST_THREAD_FUTURE<Rp> |
| detail::make_future_deferred_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c); |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| template <class> friend class packaged_task;// todo check if this works in windows |
| #else |
| friend class packaged_task<R>; |
| #endif |
| shared_future(future_ptr a_future): |
| base_type(a_future) |
| {} |
| |
| public: |
| BOOST_THREAD_COPYABLE_AND_MOVABLE(shared_future) |
| typedef R value_type; // EXTENSION |
| |
| shared_future(shared_future const& other): |
| base_type(other.future_) |
| {} |
| |
| typedef future_state::state state; |
| |
| BOOST_CONSTEXPR shared_future() |
| {} |
| //BOOST_CONSTEXPR |
| shared_future(exceptional_ptr const& ex): |
| base_type(ex) {} |
| ~shared_future() |
| {} |
| |
| shared_future& operator=(BOOST_THREAD_COPY_ASSIGN_REF(shared_future) other) |
| { |
| if (other.future_) { |
| other.future_->inc(); |
| } |
| if (this->future_) { |
| this->future_->dec(); |
| } |
| this->future_ = other.future_; |
| return *this; |
| } |
| |
| shared_future(BOOST_THREAD_RV_REF(shared_future) other) BOOST_NOEXCEPT : |
| base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))) |
| { |
| } |
| shared_future(BOOST_THREAD_RV_REF( BOOST_THREAD_FUTURE<R> ) other) BOOST_NOEXCEPT : |
| base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))) |
| { |
| } |
| |
| shared_future& operator=(BOOST_THREAD_RV_REF(shared_future) other) BOOST_NOEXCEPT |
| { |
| base_type::operator=(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))); |
| return *this; |
| } |
| shared_future& operator=(BOOST_THREAD_RV_REF( BOOST_THREAD_FUTURE<R> ) other) BOOST_NOEXCEPT |
| { |
| base_type::operator=(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other)))); |
| return *this; |
| } |
| |
| void swap(shared_future& other) BOOST_NOEXCEPT |
| { |
| static_cast<base_type*>(this)->swap(other); |
| } |
| bool run_if_is_deferred() { |
| return this->future_->run_if_is_deferred(); |
| } |
| bool run_if_is_deferred_or_ready() { |
| return this->future_->run_if_is_deferred_or_ready(); |
| } |
| // retrieving the value |
| typename detail::shared_state<R>::shared_future_get_result_type get() const |
| { |
| if(!this->future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| return this->future_->get_sh(); |
| } |
| |
| template <typename R2> |
| typename boost::disable_if< is_void<R2>, typename detail::shared_state<R>::shared_future_get_result_type>::type |
| get_or(BOOST_THREAD_RV_REF(R2) v) const // EXTENSION |
| { |
| if(!this->future_) |
| { |
| boost::throw_exception(future_uninitialized()); |
| } |
| this->future_->wait(); |
| if (this->future_->has_value()) return this->future_->get_sh(); |
| else return boost::move(v); |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| template<typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(shared_future)>::type> |
| then(BOOST_THREAD_FWD_REF(F) func) const; // EXTENSION |
| template<typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(shared_future)>::type> |
| then(launch policy, BOOST_THREAD_FWD_REF(F) func) const; // EXTENSION |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template<typename Ex, typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(shared_future)>::type> |
| then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) const; // EXTENSION |
| #endif |
| #endif |
| |
| }; |
| |
| BOOST_THREAD_DCL_MOVABLE_BEG(T) shared_future<T> BOOST_THREAD_DCL_MOVABLE_END |
| |
| template <typename R> |
| class promise |
| { |
| typedef boost::shared_ptr<detail::shared_state<R> > future_ptr; |
| |
| typedef typename detail::shared_state<R>::source_reference_type source_reference_type; |
| typedef typename detail::shared_state<R>::rvalue_source_type rvalue_source_type; |
| typedef typename detail::shared_state<R>::move_dest_type move_dest_type; |
| typedef typename detail::shared_state<R>::shared_future_get_result_type shared_future_get_result_type; |
| |
| future_ptr future_; |
| bool future_obtained; |
| |
| void lazy_init() |
| { |
| #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY |
| #include <boost/detail/atomic_undef_macros.hpp> |
| if(!atomic_load(&future_)) |
| { |
| future_ptr blank; |
| atomic_compare_exchange(&future_,&blank,future_ptr(new detail::shared_state<R>)); |
| } |
| #include <boost/detail/atomic_redef_macros.hpp> |
| #endif |
| } |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(promise) |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| template <class Allocator> |
| promise(boost::allocator_arg_t, Allocator a) |
| { |
| typedef typename Allocator::template rebind<detail::shared_state<R> >::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| future_ = future_ptr(::new(a2.allocate(1)) detail::shared_state<R>(), D(a2, 1) ); |
| future_obtained = false; |
| } |
| #endif |
| promise(): |
| #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY |
| future_(), |
| #else |
| future_(new detail::shared_state<R>()), |
| #endif |
| future_obtained(false) |
| {} |
| |
| ~promise() |
| { |
| if(future_) |
| { |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| |
| if(!future_->done && !future_->is_constructed) |
| { |
| future_->mark_exceptional_finish_internal(boost::copy_exception(broken_promise()), lock); |
| } |
| } |
| } |
| |
| // Assignment |
| promise(BOOST_THREAD_RV_REF(promise) rhs) BOOST_NOEXCEPT : |
| future_(BOOST_THREAD_RV(rhs).future_),future_obtained(BOOST_THREAD_RV(rhs).future_obtained) |
| { |
| BOOST_THREAD_RV(rhs).future_.reset(); |
| BOOST_THREAD_RV(rhs).future_obtained=false; |
| } |
| promise & operator=(BOOST_THREAD_RV_REF(promise) rhs) BOOST_NOEXCEPT |
| { |
| future_=BOOST_THREAD_RV(rhs).future_; |
| future_obtained=BOOST_THREAD_RV(rhs).future_obtained; |
| BOOST_THREAD_RV(rhs).future_.reset(); |
| BOOST_THREAD_RV(rhs).future_obtained=false; |
| return *this; |
| } |
| |
| void swap(promise& other) |
| { |
| future_.swap(other.future_); |
| std::swap(future_obtained,other.future_obtained); |
| } |
| |
| // Result retrieval |
| BOOST_THREAD_FUTURE<R> get_future() |
| { |
| lazy_init(); |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| if (future_obtained) |
| { |
| boost::throw_exception(future_already_retrieved()); |
| } |
| future_obtained=true; |
| return BOOST_THREAD_FUTURE<R>(future_); |
| } |
| |
| #if defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| template <class TR> |
| typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type set_value(TR const & r) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_finished_with_result_internal(r, lock); |
| } |
| #else |
| void set_value(source_reference_type r) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_finished_with_result_internal(r, lock); |
| } |
| #endif |
| |
| void set_value(rvalue_source_type r) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| future_->mark_finished_with_result_internal(boost::move(r), lock); |
| #else |
| future_->mark_finished_with_result_internal(static_cast<rvalue_source_type>(r), lock); |
| #endif |
| } |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template <class ...Args> |
| void emplace(BOOST_THREAD_FWD_REF(Args) ...args) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_finished_with_result_internal(lock, boost::forward<Args>(args)...); |
| } |
| |
| #endif |
| |
| void set_exception(boost::exception_ptr p) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_exceptional_finish_internal(p, lock); |
| } |
| template <typename E> |
| void set_exception(E ex) |
| { |
| set_exception(boost::copy_exception(ex)); |
| } |
| // setting the result with deferred notification |
| #if defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| template <class TR> |
| typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type set_value_at_thread_exit(TR const& r) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_value_at_thread_exit(r); |
| } |
| #else |
| void set_value_at_thread_exit(source_reference_type r) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_value_at_thread_exit(r); |
| } |
| #endif |
| void set_value_at_thread_exit(BOOST_THREAD_RV_REF(R) r) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_value_at_thread_exit(boost::move(r)); |
| } |
| void set_exception_at_thread_exit(exception_ptr e) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_exception_at_thread_exit(e); |
| } |
| template <typename E> |
| void set_exception_at_thread_exit(E ex) |
| { |
| set_exception_at_thread_exit(boost::copy_exception(ex)); |
| } |
| |
| template<typename F> |
| void set_wait_callback(F f) |
| { |
| lazy_init(); |
| future_->set_wait_callback(f,this); |
| } |
| |
| }; |
| |
| template <typename R> |
| class promise<R&> |
| { |
| typedef boost::shared_ptr<detail::shared_state<R&> > future_ptr; |
| |
| future_ptr future_; |
| bool future_obtained; |
| |
| void lazy_init() |
| { |
| #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY |
| #include <boost/detail/atomic_undef_macros.hpp> |
| if(!atomic_load(&future_)) |
| { |
| future_ptr blank; |
| atomic_compare_exchange(&future_,&blank,future_ptr(new detail::shared_state<R&>)); |
| } |
| #include <boost/detail/atomic_redef_macros.hpp> |
| #endif |
| } |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(promise) |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| template <class Allocator> |
| promise(boost::allocator_arg_t, Allocator a) |
| { |
| typedef typename Allocator::template rebind<detail::shared_state<R&> >::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| future_ = future_ptr(::new(a2.allocate(1)) detail::shared_state<R&>(), D(a2, 1) ); |
| future_obtained = false; |
| } |
| #endif |
| promise(): |
| #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY |
| future_(), |
| #else |
| future_(new detail::shared_state<R&>()), |
| #endif |
| future_obtained(false) |
| {} |
| |
| ~promise() |
| { |
| if(future_) |
| { |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| |
| if(!future_->done && !future_->is_constructed) |
| { |
| future_->mark_exceptional_finish_internal(boost::copy_exception(broken_promise()), lock); |
| } |
| } |
| } |
| |
| // Assignment |
| promise(BOOST_THREAD_RV_REF(promise) rhs) BOOST_NOEXCEPT : |
| future_(BOOST_THREAD_RV(rhs).future_),future_obtained(BOOST_THREAD_RV(rhs).future_obtained) |
| { |
| BOOST_THREAD_RV(rhs).future_.reset(); |
| BOOST_THREAD_RV(rhs).future_obtained=false; |
| } |
| promise & operator=(BOOST_THREAD_RV_REF(promise) rhs) BOOST_NOEXCEPT |
| { |
| future_=BOOST_THREAD_RV(rhs).future_; |
| future_obtained=BOOST_THREAD_RV(rhs).future_obtained; |
| BOOST_THREAD_RV(rhs).future_.reset(); |
| BOOST_THREAD_RV(rhs).future_obtained=false; |
| return *this; |
| } |
| |
| void swap(promise& other) |
| { |
| future_.swap(other.future_); |
| std::swap(future_obtained,other.future_obtained); |
| } |
| |
| // Result retrieval |
| BOOST_THREAD_FUTURE<R&> get_future() |
| { |
| lazy_init(); |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| if (future_obtained) |
| { |
| boost::throw_exception(future_already_retrieved()); |
| } |
| future_obtained=true; |
| return BOOST_THREAD_FUTURE<R&>(future_); |
| } |
| |
| void set_value(R& r) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_finished_with_result_internal(r, lock); |
| } |
| |
| void set_exception(boost::exception_ptr p) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_exceptional_finish_internal(p, lock); |
| } |
| template <typename E> |
| void set_exception(E ex) |
| { |
| set_exception(boost::copy_exception(ex)); |
| } |
| |
| // setting the result with deferred notification |
| void set_value_at_thread_exit(R& r) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_value_at_thread_exit(r); |
| } |
| |
| void set_exception_at_thread_exit(exception_ptr e) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_exception_at_thread_exit(e); |
| } |
| template <typename E> |
| void set_exception_at_thread_exit(E ex) |
| { |
| set_exception_at_thread_exit(boost::copy_exception(ex)); |
| } |
| |
| template<typename F> |
| void set_wait_callback(F f) |
| { |
| lazy_init(); |
| future_->set_wait_callback(f,this); |
| } |
| }; |
| |
| template <> |
| class promise<void> |
| { |
| typedef boost::shared_ptr<detail::shared_state<void> > future_ptr; |
| |
| future_ptr future_; |
| bool future_obtained; |
| |
| void lazy_init() |
| { |
| #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY |
| if(!atomic_load(&future_)) |
| { |
| future_ptr blank; |
| atomic_compare_exchange(&future_,&blank,future_ptr(new detail::shared_state<void>)); |
| } |
| #endif |
| } |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(promise) |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| template <class Allocator> |
| promise(boost::allocator_arg_t, Allocator a) |
| { |
| typedef typename Allocator::template rebind<detail::shared_state<void> >::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| future_ = future_ptr(::new(a2.allocate(1)) detail::shared_state<void>(), D(a2, 1) ); |
| future_obtained = false; |
| } |
| #endif |
| promise(): |
| #if defined BOOST_THREAD_PROVIDES_PROMISE_LAZY |
| future_(), |
| #else |
| future_(new detail::shared_state<void>), |
| #endif |
| future_obtained(false) |
| {} |
| |
| ~promise() |
| { |
| if(future_) |
| { |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| |
| if(!future_->done && !future_->is_constructed) |
| { |
| future_->mark_exceptional_finish_internal(boost::copy_exception(broken_promise()), lock); |
| } |
| } |
| } |
| |
| // Assignment |
| promise(BOOST_THREAD_RV_REF(promise) rhs) BOOST_NOEXCEPT : |
| future_(BOOST_THREAD_RV(rhs).future_),future_obtained(BOOST_THREAD_RV(rhs).future_obtained) |
| { |
| // we need to release the future as shared_ptr doesn't implements move semantics |
| BOOST_THREAD_RV(rhs).future_.reset(); |
| BOOST_THREAD_RV(rhs).future_obtained=false; |
| } |
| |
| promise & operator=(BOOST_THREAD_RV_REF(promise) rhs) BOOST_NOEXCEPT |
| { |
| future_=BOOST_THREAD_RV(rhs).future_; |
| future_obtained=BOOST_THREAD_RV(rhs).future_obtained; |
| BOOST_THREAD_RV(rhs).future_.reset(); |
| BOOST_THREAD_RV(rhs).future_obtained=false; |
| return *this; |
| } |
| |
| void swap(promise& other) |
| { |
| future_.swap(other.future_); |
| std::swap(future_obtained,other.future_obtained); |
| } |
| |
| // Result retrieval |
| BOOST_THREAD_FUTURE<void> get_future() |
| { |
| lazy_init(); |
| |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| if(future_obtained) |
| { |
| boost::throw_exception(future_already_retrieved()); |
| } |
| future_obtained=true; |
| //return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<void>(future_)); |
| return BOOST_THREAD_FUTURE<void>(future_); |
| } |
| |
| void set_value() |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_finished_with_result_internal(lock); |
| } |
| |
| void set_exception(boost::exception_ptr p) |
| { |
| lazy_init(); |
| boost::unique_lock<boost::mutex> lock(future_->mutex); |
| if(future_->done) |
| { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| future_->mark_exceptional_finish_internal(p,lock); |
| } |
| template <typename E> |
| void set_exception(E ex) |
| { |
| set_exception(boost::copy_exception(ex)); |
| } |
| |
| // setting the result with deferred notification |
| void set_value_at_thread_exit() |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_value_at_thread_exit(); |
| } |
| |
| void set_exception_at_thread_exit(exception_ptr e) |
| { |
| if (future_.get()==0) |
| { |
| boost::throw_exception(promise_moved()); |
| } |
| future_->set_exception_at_thread_exit(e); |
| } |
| template <typename E> |
| void set_exception_at_thread_exit(E ex) |
| { |
| set_exception_at_thread_exit(boost::copy_exception(ex)); |
| } |
| |
| template<typename F> |
| void set_wait_callback(F f) |
| { |
| lazy_init(); |
| future_->set_wait_callback(f,this); |
| } |
| |
| }; |
| } |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| namespace boost { namespace container { |
| template <class R, class Alloc> |
| struct uses_allocator< ::boost::promise<R> , Alloc> : true_type |
| { |
| }; |
| }} |
| #if ! defined BOOST_NO_CXX11_ALLOCATOR |
| namespace std { |
| template <class R, class Alloc> |
| struct uses_allocator< ::boost::promise<R> , Alloc> : true_type |
| { |
| }; |
| } |
| #endif |
| #endif |
| |
| namespace boost |
| { |
| |
| BOOST_THREAD_DCL_MOVABLE_BEG(T) promise<T> BOOST_THREAD_DCL_MOVABLE_END |
| |
| namespace detail |
| { |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| template<typename R> |
| struct task_base_shared_state; |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename R, typename ...ArgTypes> |
| struct task_base_shared_state<R(ArgTypes...)>: |
| #else |
| template<typename R> |
| struct task_base_shared_state<R()>: |
| #endif |
| #else |
| template<typename R> |
| struct task_base_shared_state: |
| #endif |
| detail::shared_state<R> |
| { |
| bool started; |
| |
| task_base_shared_state(): |
| started(false) |
| {} |
| |
| void reset() |
| { |
| // todo The packaged_task::reset must be as if an assignemnt froma new packaged_task with the same function |
| // the reset function is an optimization that avoids reallocating a new task. |
| started=false; |
| this->validate(); |
| } |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| virtual void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args)=0; |
| void run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| #else |
| virtual void do_run()=0; |
| void run() |
| #endif |
| { |
| { |
| boost::lock_guard<boost::mutex> lk(this->mutex); |
| if(started) |
| { |
| boost::throw_exception(task_already_started()); |
| } |
| started=true; |
| } |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| do_run(boost::move(args)...); |
| #else |
| do_run(); |
| #endif |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| virtual void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args)=0; |
| void apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| #else |
| virtual void do_apply()=0; |
| void apply() |
| #endif |
| { |
| { |
| boost::lock_guard<boost::mutex> lk(this->mutex); |
| if(started) |
| { |
| boost::throw_exception(task_already_started()); |
| } |
| started=true; |
| } |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| do_apply(boost::move(args)...); |
| #else |
| do_apply(); |
| #endif |
| } |
| |
| void owner_destroyed() |
| { |
| boost::unique_lock<boost::mutex> lk(this->mutex); |
| if(!started) |
| { |
| started=true; |
| this->mark_exceptional_finish_internal(boost::copy_exception(boost::broken_promise()), lk); |
| } |
| } |
| }; |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| template<typename F, typename R> |
| struct task_shared_state; |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename F, typename R, typename ...ArgTypes> |
| struct task_shared_state<F, R(ArgTypes...)>: |
| task_base_shared_state<R(ArgTypes...)> |
| #else |
| template<typename F, typename R> |
| struct task_shared_state<F, R()>: |
| task_base_shared_state<R()> |
| #endif |
| #else |
| template<typename F, typename R> |
| struct task_shared_state: |
| task_base_shared_state<R> |
| #endif |
| { |
| private: |
| task_shared_state(task_shared_state&); |
| public: |
| F f; |
| task_shared_state(F const& f_): |
| f(f_) |
| {} |
| task_shared_state(BOOST_THREAD_RV_REF(F) f_): |
| f(boost::move(f_)) |
| {} |
| |
| F callable() |
| { |
| return boost::move(f); |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f(boost::move(args)...)); |
| } |
| #else |
| void do_apply() |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f()); |
| } |
| #endif |
| catch(...) |
| { |
| this->set_exception_at_thread_exit(current_exception()); |
| } |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->mark_finished_with_result(f(boost::move(args)...)); |
| } |
| #else |
| void do_run() |
| { |
| try |
| { |
| #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| R res((f())); |
| this->mark_finished_with_result(boost::move(res)); |
| #else |
| this->mark_finished_with_result(f()); |
| #endif |
| } |
| #endif |
| catch(...) |
| { |
| this->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename F, typename R, typename ...ArgTypes> |
| struct task_shared_state<F, R&(ArgTypes...)>: |
| task_base_shared_state<R&(ArgTypes...)> |
| #else |
| template<typename F, typename R> |
| struct task_shared_state<F, R&()>: |
| task_base_shared_state<R&()> |
| #endif |
| #else |
| template<typename F, typename R> |
| struct task_shared_state<F,R&>: |
| task_base_shared_state<R&> |
| #endif |
| { |
| private: |
| task_shared_state(task_shared_state&); |
| public: |
| F f; |
| task_shared_state(F const& f_): |
| f(f_) |
| {} |
| task_shared_state(BOOST_THREAD_RV_REF(F) f_): |
| f(boost::move(f_)) |
| {} |
| |
| F callable() |
| { |
| return f; |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f(boost::move(args)...)); |
| } |
| #else |
| void do_apply() |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f()); |
| } |
| #endif |
| catch(...) |
| { |
| this->set_exception_at_thread_exit(current_exception()); |
| } |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->mark_finished_with_result(f(boost::move(args)...)); |
| } |
| #else |
| void do_run() |
| { |
| try |
| { |
| R& res((f())); |
| this->mark_finished_with_result(res); |
| } |
| #endif |
| catch(...) |
| { |
| this->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| #if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR) |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename R, typename ...ArgTypes> |
| struct task_shared_state<R (*)(ArgTypes...), R(ArgTypes...)>: |
| task_base_shared_state<R(ArgTypes...)> |
| #else |
| template<typename R> |
| struct task_shared_state<R (*)(), R()>: |
| task_base_shared_state<R()> |
| #endif |
| #else |
| template<typename R> |
| struct task_shared_state<R (*)(), R> : |
| task_base_shared_state<R> |
| #endif |
| { |
| private: |
| task_shared_state(task_shared_state&); |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef R (*CallableType)(BOOST_THREAD_RV_REF(ArgTypes) ... ); |
| #else |
| typedef R (*CallableType)(); |
| #endif |
| public: |
| CallableType f; |
| task_shared_state(CallableType f_): |
| f(f_) |
| {} |
| |
| CallableType callable() |
| { |
| return f; |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f(boost::move(args)...)); |
| } |
| #else |
| void do_apply() |
| { |
| try |
| { |
| R r((f())); |
| this->set_value_at_thread_exit(boost::move(r)); |
| } |
| #endif |
| catch(...) |
| { |
| this->set_exception_at_thread_exit(current_exception()); |
| } |
| } |
| |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->mark_finished_with_result(f(boost::move(args)...)); |
| } |
| #else |
| void do_run() |
| { |
| try |
| { |
| R res((f())); |
| this->mark_finished_with_result(boost::move(res)); |
| } |
| #endif |
| catch(...) |
| { |
| this->mark_exceptional_finish(); |
| } |
| } |
| }; |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename R, typename ...ArgTypes> |
| struct task_shared_state<R& (*)(ArgTypes...), R&(ArgTypes...)>: |
| task_base_shared_state<R&(ArgTypes...)> |
| #else |
| template<typename R> |
| struct task_shared_state<R& (*)(), R&()>: |
| task_base_shared_state<R&()> |
| #endif |
| #else |
| template<typename R> |
| struct task_shared_state<R& (*)(), R&> : |
| task_base_shared_state<R&> |
| #endif |
| { |
| private: |
| task_shared_state(task_shared_state&); |
| public: |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef R& (*CallableType)(BOOST_THREAD_RV_REF(ArgTypes) ... ); |
| #else |
| typedef R& (*CallableType)(); |
| #endif |
| CallableType f; |
| task_shared_state(CallableType f_): |
| f(f_) |
| {} |
| |
| CallableType callable() |
| { |
| return boost::move(f); |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f(boost::move(args)...)); |
| } |
| #else |
| void do_apply() |
| { |
| try |
| { |
| this->set_value_at_thread_exit(f()); |
| } |
| #endif |
| catch(...) |
| { |
| this->set_exception_at_thread_exit(current_exception()); |
| } |
| } |
| |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| this->mark_finished_with_result(f(boost::move(args)...)); |
| } |
| #else |
| void do_run() |
| { |
| try |
| { |
| this->mark_finished_with_result(f()); |
| } |
| #endif |
| catch(...) |
| { |
| this->mark_exceptional_finish(); |
| } |
| } |
| }; |
| #endif |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename F, typename ...ArgTypes> |
| struct task_shared_state<F, void(ArgTypes...)>: |
| task_base_shared_state<void(ArgTypes...)> |
| #else |
| template<typename F> |
| struct task_shared_state<F, void()>: |
| task_base_shared_state<void()> |
| #endif |
| #else |
| template<typename F> |
| struct task_shared_state<F,void>: |
| task_base_shared_state<void> |
| #endif |
| { |
| private: |
| task_shared_state(task_shared_state&); |
| public: |
| typedef F CallableType; |
| F f; |
| task_shared_state(F const& f_): |
| f(f_) |
| {} |
| task_shared_state(BOOST_THREAD_RV_REF(F) f_): |
| f(boost::move(f_)) |
| {} |
| F callable() |
| { |
| return boost::move(f); |
| } |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| f(boost::move(args)...); |
| #else |
| void do_apply() |
| { |
| try |
| { |
| f(); |
| #endif |
| this->set_value_at_thread_exit(); |
| } |
| catch(...) |
| { |
| this->set_exception_at_thread_exit(current_exception()); |
| } |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| f(boost::move(args)...); |
| #else |
| void do_run() |
| { |
| try |
| { |
| f(); |
| #endif |
| this->mark_finished_with_result(); |
| } |
| catch(...) |
| { |
| this->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename ...ArgTypes> |
| struct task_shared_state<void (*)(ArgTypes...), void(ArgTypes...)>: |
| task_base_shared_state<void(ArgTypes...)> |
| #else |
| template<> |
| struct task_shared_state<void (*)(), void()>: |
| task_base_shared_state<void()> |
| #endif |
| #else |
| template<> |
| struct task_shared_state<void (*)(),void>: |
| task_base_shared_state<void> |
| #endif |
| { |
| private: |
| task_shared_state(task_shared_state&); |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef void (*CallableType)(BOOST_THREAD_RV_REF(ArgTypes)...); |
| #else |
| typedef void (*CallableType)(); |
| #endif |
| public: |
| CallableType f; |
| task_shared_state(CallableType f_): |
| f(f_) |
| {} |
| CallableType callable() |
| { |
| return f; |
| } |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_apply(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| f(boost::move(args)...); |
| #else |
| void do_apply() |
| { |
| try |
| { |
| f(); |
| #endif |
| this->set_value_at_thread_exit(); |
| } |
| catch(...) |
| { |
| this->set_exception_at_thread_exit(current_exception()); |
| } |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void do_run(BOOST_THREAD_RV_REF(ArgTypes) ... args) |
| { |
| try |
| { |
| f(boost::move(args)...); |
| #else |
| void do_run() |
| { |
| try |
| { |
| f(); |
| #endif |
| this->mark_finished_with_result(); |
| } |
| catch(...) |
| { |
| this->mark_exceptional_finish(); |
| } |
| } |
| }; |
| } |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template<typename R, typename ...ArgTypes> |
| class packaged_task<R(ArgTypes...)> |
| { |
| typedef boost::shared_ptr<detail::task_base_shared_state<R(ArgTypes...)> > task_ptr; |
| boost::shared_ptr<detail::task_base_shared_state<R(ArgTypes...)> > task; |
| #else |
| template<typename R> |
| class packaged_task<R()> |
| { |
| typedef boost::shared_ptr<detail::task_base_shared_state<R()> > task_ptr; |
| boost::shared_ptr<detail::task_base_shared_state<R()> > task; |
| #endif |
| #else |
| template<typename R> |
| class packaged_task |
| { |
| typedef boost::shared_ptr<detail::task_base_shared_state<R> > task_ptr; |
| boost::shared_ptr<detail::task_base_shared_state<R> > task; |
| #endif |
| bool future_obtained; |
| struct dummy; |
| |
| public: |
| typedef R result_type; |
| BOOST_THREAD_MOVABLE_ONLY(packaged_task) |
| |
| packaged_task(): |
| future_obtained(false) |
| {} |
| |
| // construction and destruction |
| #if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR) |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| explicit packaged_task(R(*f)(), BOOST_THREAD_FWD_REF(ArgTypes)... args) |
| { |
| typedef R(*FR)(BOOST_THREAD_FWD_REF(ArgTypes)...); |
| typedef detail::task_shared_state<FR,R(ArgTypes...)> task_shared_state_type; |
| task= task_ptr(new task_shared_state_type(f, boost::move(args)...)); |
| future_obtained=false; |
| } |
| #else |
| explicit packaged_task(R(*f)()) |
| { |
| typedef R(*FR)(); |
| typedef detail::task_shared_state<FR,R()> task_shared_state_type; |
| task= task_ptr(new task_shared_state_type(f)); |
| future_obtained=false; |
| } |
| #endif |
| #else |
| explicit packaged_task(R(*f)()) |
| { |
| typedef R(*FR)(); |
| typedef detail::task_shared_state<FR,R> task_shared_state_type; |
| task= task_ptr(new task_shared_state_type(f)); |
| future_obtained=false; |
| } |
| #endif |
| #endif |
| #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES |
| template <class F> |
| explicit packaged_task(BOOST_THREAD_FWD_REF(F) f |
| , typename boost::disable_if<is_same<typename decay<F>::type, packaged_task>, dummy* >::type=0 |
| ) |
| { |
| typedef typename decay<F>::type FR; |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<FR,R(ArgTypes...)> task_shared_state_type; |
| #else |
| typedef detail::task_shared_state<FR,R()> task_shared_state_type; |
| #endif |
| #else |
| typedef detail::task_shared_state<FR,R> task_shared_state_type; |
| #endif |
| task = task_ptr(new task_shared_state_type(boost::forward<F>(f))); |
| future_obtained = false; |
| |
| } |
| |
| #else |
| template <class F> |
| explicit packaged_task(F const& f |
| , typename boost::disable_if<is_same<typename decay<F>::type, packaged_task>, dummy* >::type=0 |
| ) |
| { |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<F,R(ArgTypes...)> task_shared_state_type; |
| #else |
| typedef detail::task_shared_state<F,R()> task_shared_state_type; |
| #endif |
| #else |
| typedef detail::task_shared_state<F,R> task_shared_state_type; |
| #endif |
| task = task_ptr(new task_shared_state_type(f)); |
| future_obtained=false; |
| } |
| template <class F> |
| explicit packaged_task(BOOST_THREAD_RV_REF(F) f) |
| { |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<F,R(ArgTypes...)> task_shared_state_type; |
| task = task_ptr(new task_shared_state_type(boost::move(f))); |
| #else |
| typedef detail::task_shared_state<F,R()> task_shared_state_type; |
| task = task_ptr(new task_shared_state_type(boost::move(f))); |
| #endif |
| #else |
| typedef detail::task_shared_state<F,R> task_shared_state_type; |
| task = task_ptr(new task_shared_state_type(boost::move(f))); |
| #endif |
| future_obtained=false; |
| |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| #if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR) |
| template <class Allocator> |
| packaged_task(boost::allocator_arg_t, Allocator a, R(*f)()) |
| { |
| typedef R(*FR)(); |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<FR,R(ArgTypes...)> task_shared_state_type; |
| #else |
| typedef detail::task_shared_state<FR,R()> task_shared_state_type; |
| #endif |
| #else |
| typedef detail::task_shared_state<FR,R> task_shared_state_type; |
| #endif |
| typedef typename Allocator::template rebind<task_shared_state_type>::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| task = task_ptr(::new(a2.allocate(1)) task_shared_state_type(f), D(a2, 1) ); |
| future_obtained = false; |
| } |
| #endif // BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| |
| #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| template <class F, class Allocator> |
| packaged_task(boost::allocator_arg_t, Allocator a, BOOST_THREAD_FWD_REF(F) f) |
| { |
| typedef typename decay<F>::type FR; |
| |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<FR,R(ArgTypes...)> task_shared_state_type; |
| #else |
| typedef detail::task_shared_state<FR,R()> task_shared_state_type; |
| #endif |
| #else |
| typedef detail::task_shared_state<FR,R> task_shared_state_type; |
| #endif |
| typedef typename Allocator::template rebind<task_shared_state_type>::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| task = task_ptr(::new(a2.allocate(1)) task_shared_state_type(boost::forward<F>(f)), D(a2, 1) ); |
| future_obtained = false; |
| } |
| #else // ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| template <class F, class Allocator> |
| packaged_task(boost::allocator_arg_t, Allocator a, const F& f) |
| { |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<F,R(ArgTypes...)> task_shared_state_type; |
| #else |
| typedef detail::task_shared_state<F,R()> task_shared_state_type; |
| #endif |
| #else |
| typedef detail::task_shared_state<F,R> task_shared_state_type; |
| #endif |
| typedef typename Allocator::template rebind<task_shared_state_type>::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| task = task_ptr(::new(a2.allocate(1)) task_shared_state_type(f), D(a2, 1) ); |
| future_obtained = false; |
| } |
| template <class F, class Allocator> |
| packaged_task(boost::allocator_arg_t, Allocator a, BOOST_THREAD_RV_REF(F) f) |
| { |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| typedef detail::task_shared_state<F,R(ArgTypes...)> task_shared_state_type; |
| #else |
| typedef detail::task_shared_state<F,R()> task_shared_state_type; |
| #endif |
| #else |
| typedef detail::task_shared_state<F,R> task_shared_state_type; |
| #endif |
| typedef typename Allocator::template rebind<task_shared_state_type>::other A2; |
| A2 a2(a); |
| typedef thread_detail::allocator_destructor<A2> D; |
| |
| task = task_ptr(::new(a2.allocate(1)) task_shared_state_type(boost::move(f)), D(a2, 1) ); |
| future_obtained = false; |
| } |
| |
| #endif //BOOST_NO_CXX11_RVALUE_REFERENCES |
| #endif // BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| |
| ~packaged_task() { |
| if(task) { |
| task->owner_destroyed(); |
| } |
| } |
| |
| // assignment |
| packaged_task(BOOST_THREAD_RV_REF(packaged_task) other) BOOST_NOEXCEPT |
| : future_obtained(BOOST_THREAD_RV(other).future_obtained) { |
| task.swap(BOOST_THREAD_RV(other).task); |
| BOOST_THREAD_RV(other).future_obtained=false; |
| } |
| packaged_task& operator=(BOOST_THREAD_RV_REF(packaged_task) other) BOOST_NOEXCEPT { |
| |
| #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| packaged_task temp(boost::move(other)); |
| #else |
| packaged_task temp(static_cast<BOOST_THREAD_RV_REF(packaged_task)>(other)); |
| #endif |
| swap(temp); |
| return *this; |
| } |
| |
| void reset() { |
| if (!valid()) |
| throw future_error(system::make_error_code(future_errc::no_state)); |
| |
| // As if *this = packaged_task(task->callable()); |
| |
| task->reset(); |
| future_obtained=false; |
| } |
| |
| void swap(packaged_task& other) BOOST_NOEXCEPT { |
| task.swap(other.task); |
| std::swap(future_obtained,other.future_obtained); |
| } |
| bool valid() const BOOST_NOEXCEPT { |
| return task.get()!=0; |
| } |
| |
| // result retrieval |
| BOOST_THREAD_FUTURE<R> get_future() { |
| if(!task) { |
| boost::throw_exception(task_moved()); |
| } else if(!future_obtained) { |
| future_obtained=true; |
| return BOOST_THREAD_FUTURE<R>(task); |
| } else { |
| boost::throw_exception(future_already_retrieved()); |
| } |
| } |
| |
| // execution |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| void operator()(BOOST_THREAD_RV_REF(ArgTypes)... args) { |
| if(!task) { |
| boost::throw_exception(task_moved()); |
| } |
| task->run(boost::move(args)...); |
| } |
| void make_ready_at_thread_exit(ArgTypes... args) { |
| if(!task) { |
| boost::throw_exception(task_moved()); |
| } |
| if (task->has_value()) { |
| boost::throw_exception(promise_already_satisfied()); |
| } |
| task->apply(boost::move(args)...); |
| } |
| #else |
| void operator()() { |
| if(!task) { |
| boost::throw_exception(task_moved()); |
| } |
| task->run(); |
| } |
| void make_ready_at_thread_exit() { |
| if(!task) { |
| boost::throw_exception(task_moved()); |
| } |
| if (task->has_value()) boost::throw_exception(promise_already_satisfied()); |
| task->apply(); |
| } |
| #endif |
| template<typename F> |
| void set_wait_callback(F f) { |
| task->set_wait_callback(f,this); |
| } |
| }; |
| } |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS |
| namespace boost { namespace container { |
| template <class R, class Alloc> |
| struct uses_allocator< ::boost::packaged_task<R> , Alloc> : true_type |
| {}; |
| }} |
| #if ! defined BOOST_NO_CXX11_ALLOCATOR |
| namespace std { |
| template <class R, class Alloc> |
| struct uses_allocator< ::boost::packaged_task<R> , Alloc> : true_type |
| {}; |
| } |
| #endif |
| #endif |
| |
| namespace boost |
| { |
| BOOST_THREAD_DCL_MOVABLE_BEG(T) packaged_task<T> BOOST_THREAD_DCL_MOVABLE_END |
| |
| namespace detail |
| { |
| //////////////////////////////// |
| // make_future_deferred_shared_state |
| //////////////////////////////// |
| template <class Rp, class Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_deferred_shared_state(BOOST_THREAD_FWD_REF(Fp) f) { |
| shared_ptr<future_deferred_shared_state<Rp, Fp> > |
| h(new future_deferred_shared_state<Rp, Fp>(boost::forward<Fp>(f))); |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| |
| //////////////////////////////// |
| // make_future_async_shared_state |
| //////////////////////////////// |
| template <class Rp, class Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_async_shared_state(BOOST_THREAD_FWD_REF(Fp) f) { |
| shared_ptr<future_async_shared_state<Rp, Fp> > |
| h(new future_async_shared_state<Rp, Fp>()); |
| h->init(boost::forward<Fp>(f)); |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| } |
| |
| //////////////////////////////// |
| // template <class F, class... ArgTypes> |
| // future<R> async(launch policy, F&&, ArgTypes&&...); |
| //////////////////////////////// |
| |
| #if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template <class R, class... ArgTypes> |
| BOOST_THREAD_FUTURE<R> |
| async(launch policy, R(*f)(BOOST_THREAD_FWD_REF(ArgTypes)...), BOOST_THREAD_FWD_REF(ArgTypes)... args) { |
| typedef R(*F)(BOOST_THREAD_FWD_REF(ArgTypes)...); |
| typedef detail::invoker<typename decay<F>::type, typename decay<ArgTypes>::type...> BF; |
| typedef typename BF::result_type Rp; |
| |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_async_shared_state<Rp>( |
| BF( |
| f |
| , thread_detail::decay_copy(boost::forward<ArgTypes>(args))... |
| ) |
| )); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_deferred_shared_state<Rp>( |
| BF( |
| f |
| , thread_detail::decay_copy(boost::forward<ArgTypes>(args))... |
| ) |
| )); |
| } else { |
| std::terminate(); |
| BOOST_THREAD_FUTURE<R> ret; |
| return ::boost::move(ret); |
| } |
| } |
| |
| #else // defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| |
| template <class R> |
| BOOST_THREAD_FUTURE<R> |
| async(launch policy, R(*f)()) { |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| typedef packaged_task<R()> packaged_task_type; |
| #else |
| typedef packaged_task<R> packaged_task_type; |
| #endif |
| |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| packaged_task_type pt( f ); |
| BOOST_THREAD_FUTURE<R> ret = BOOST_THREAD_MAKE_RV_REF(pt.get_future()); |
| ret.set_async(); |
| boost::thread( boost::move(pt) ).detach(); |
| return ::boost::move(ret); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| std::terminate(); |
| BOOST_THREAD_FUTURE<R> ret; |
| return ::boost::move(ret); |
| } else { |
| std::terminate(); |
| BOOST_THREAD_FUTURE<R> ret; |
| return ::boost::move(ret); |
| } |
| } |
| #endif |
| #endif // defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR) |
| |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| |
| template <class F, class ...ArgTypes> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type( |
| typename decay<ArgTypes>::type... |
| )>::type> |
| async(launch policy, BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(ArgTypes)... args) { |
| typedef typename boost::result_of<typename decay<F>::type( |
| typename decay<ArgTypes>::type... |
| )>::type R; |
| typedef detail::invoker<typename decay<F>::type, typename decay<ArgTypes>::type...> BF; |
| typedef typename BF::result_type Rp; |
| |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_async_shared_state<Rp>( |
| BF( |
| thread_detail::decay_copy(boost::forward<F>(f)) |
| , thread_detail::decay_copy(boost::forward<ArgTypes>(args))... |
| ) |
| )); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_deferred_shared_state<Rp>( |
| BF( |
| thread_detail::decay_copy(boost::forward<F>(f)) |
| , thread_detail::decay_copy(boost::forward<ArgTypes>(args))... |
| ) |
| )); |
| } else { |
| std::terminate(); |
| BOOST_THREAD_FUTURE<R> ret; |
| return ::boost::move(ret); |
| } |
| } |
| |
| #else // defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| |
| template <class F> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type()>::type> |
| async(launch policy, BOOST_THREAD_FWD_REF(F) f) { |
| typedef typename boost::result_of<typename decay<F>::type()>::type R; |
| #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| typedef packaged_task<R()> packaged_task_type; |
| #else // defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| typedef packaged_task<R> packaged_task_type; |
| #endif // defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK |
| |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| packaged_task_type pt( boost::forward<F>(f) ); |
| BOOST_THREAD_FUTURE<R> ret = pt.get_future(); |
| ret.set_async(); |
| boost::thread( boost::move(pt) ).detach(); |
| return ::boost::move(ret); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| std::terminate(); |
| BOOST_THREAD_FUTURE<R> ret; |
| return ::boost::move(ret); |
| // return boost::detail::make_future_deferred_shared_state<Rp>( |
| // BF( |
| // thread_detail::decay_copy(boost::forward<F>(f)) |
| // ) |
| // ); |
| } else { |
| std::terminate(); |
| BOOST_THREAD_FUTURE<R> ret; |
| return ::boost::move(ret); |
| } |
| } |
| #endif // defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| namespace detail { |
| ///////////////////////// |
| /// shared_state_nullary_task |
| ///////////////////////// |
| template<typename Rp, typename Fp> |
| struct shared_state_nullary_task |
| { |
| shared_state<Rp>* that; |
| Fp f_; |
| public: |
| |
| shared_state_nullary_task(shared_state<Rp>* st, BOOST_THREAD_FWD_REF(Fp) f) |
| : that(st), f_(boost::move(f)) |
| {}; |
| #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) |
| BOOST_THREAD_COPYABLE_AND_MOVABLE(shared_state_nullary_task) |
| shared_state_nullary_task(shared_state_nullary_task const& x) //BOOST_NOEXCEPT |
| : that(x.that), f_(x.f_) |
| {} |
| shared_state_nullary_task& operator=(BOOST_THREAD_COPY_ASSIGN_REF(shared_state_nullary_task) x) //BOOST_NOEXCEPT |
| { |
| if (this != &x) { |
| that=x.that; |
| f_=x.f_; |
| } |
| return *this; |
| } |
| // move |
| shared_state_nullary_task(BOOST_THREAD_RV_REF(shared_state_nullary_task) x) //BOOST_NOEXCEPT |
| : that(x.that), f_(boost::move(x.f_)) |
| { |
| x.that=0; |
| } |
| shared_state_nullary_task& operator=(BOOST_THREAD_RV_REF(shared_state_nullary_task) x) //BOOST_NOEXCEPT |
| { |
| if (this != &x) { |
| that=x.that; |
| f_=boost::move(x.f_); |
| x.that=0; |
| } |
| return *this; |
| } |
| #endif |
| void operator()() { |
| try { |
| that->mark_finished_with_result(f_()); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| template<typename Fp> |
| struct shared_state_nullary_task<void, Fp> |
| { |
| shared_state<void>* that; |
| Fp f_; |
| public: |
| shared_state_nullary_task(shared_state<void>* st, BOOST_THREAD_FWD_REF(Fp) f) |
| : that(st), f_(boost::move(f)) |
| {}; |
| #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) |
| BOOST_THREAD_COPYABLE_AND_MOVABLE(shared_state_nullary_task) |
| shared_state_nullary_task(shared_state_nullary_task const& x) //BOOST_NOEXCEPT |
| : that(x.that), f_(x.f_) |
| {} |
| shared_state_nullary_task& operator=(BOOST_THREAD_COPY_ASSIGN_REF(shared_state_nullary_task) x) //BOOST_NOEXCEPT |
| { |
| if (this != &x) { |
| that=x.that; |
| f_=x.f_; |
| } |
| return *this; |
| } |
| // move |
| shared_state_nullary_task(BOOST_THREAD_RV_REF(shared_state_nullary_task) x) BOOST_NOEXCEPT |
| : that(x.that), f_(boost::move(x.f_)) |
| { |
| x.that=0; |
| } |
| shared_state_nullary_task& operator=(BOOST_THREAD_RV_REF(shared_state_nullary_task) x) BOOST_NOEXCEPT { |
| if (this != &x) { |
| that=x.that; |
| f_=boost::move(x.f_); |
| x.that=0; |
| } |
| return *this; |
| } |
| #endif |
| void operator()() { |
| try { |
| f_(); |
| that->mark_finished_with_result(); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| template<typename Rp, typename Fp> |
| struct shared_state_nullary_task<Rp&, Fp> |
| { |
| shared_state<Rp&>* that; |
| Fp f_; |
| public: |
| shared_state_nullary_task(shared_state<Rp&>* st, BOOST_THREAD_FWD_REF(Fp) f) |
| : that(st), f_(boost::move(f)) |
| {} |
| #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) |
| BOOST_THREAD_COPYABLE_AND_MOVABLE(shared_state_nullary_task) |
| shared_state_nullary_task(shared_state_nullary_task const& x) BOOST_NOEXCEPT |
| : that(x.that), f_(x.f_) {} |
| |
| shared_state_nullary_task& operator=(BOOST_THREAD_COPY_ASSIGN_REF(shared_state_nullary_task) x) BOOST_NOEXCEPT { |
| if (this != &x){ |
| that=x.that; |
| f_=x.f_; |
| } |
| return *this; |
| } |
| // move |
| shared_state_nullary_task(BOOST_THREAD_RV_REF(shared_state_nullary_task) x) BOOST_NOEXCEPT |
| : that(x.that), f_(boost::move(x.f_)) |
| { |
| x.that=0; |
| } |
| shared_state_nullary_task& operator=(BOOST_THREAD_RV_REF(shared_state_nullary_task) x) BOOST_NOEXCEPT { |
| if (this != &x) { |
| that=x.that; |
| f_=boost::move(x.f_); |
| x.that=0; |
| } |
| return *this; |
| } |
| #endif |
| void operator()() { |
| try { |
| that->mark_finished_with_result(f_()); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| }; |
| |
| ///////////////////////// |
| /// future_executor_shared_state_base |
| ///////////////////////// |
| template<typename Rp, typename Executor> |
| struct future_executor_shared_state: shared_state<Rp> |
| { |
| typedef shared_state<Rp> base_type; |
| protected: |
| public: |
| template<typename Fp> |
| future_executor_shared_state(Executor& ex, BOOST_THREAD_FWD_REF(Fp) f) { |
| this->set_executor(); |
| shared_state_nullary_task<Rp,Fp> t(this, boost::forward<Fp>(f)); |
| ex.submit(boost::move(t)); |
| } |
| |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>&lk) |
| { |
| this->wait(lk, false); |
| } |
| |
| ~future_executor_shared_state() {} |
| }; |
| |
| //////////////////////////////// |
| // make_future_executor_shared_state |
| //////////////////////////////// |
| template <class Rp, class Fp, class Executor> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_executor_shared_state(Executor& ex, BOOST_THREAD_FWD_REF(Fp) f) { |
| shared_ptr<future_executor_shared_state<Rp, Executor> > |
| h(new future_executor_shared_state<Rp, Executor>(ex, boost::forward<Fp>(f))); |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| |
| } // detail |
| |
| //////////////////////////////// |
| // template <class Executor, class F, class... ArgTypes> |
| // future<R> async(Executor& ex, F&&, ArgTypes&&...); |
| //////////////////////////////// |
| |
| //#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| #if defined(BOOST_THREAD_PROVIDES_INVOKE) && ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ! defined(BOOST_NO_CXX11_HDR_TUPLE) |
| |
| #if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| |
| template <class Executor, class R, class... ArgTypes> |
| BOOST_THREAD_FUTURE<R> |
| async(Executor& ex, R(*f)(BOOST_THREAD_FWD_REF(ArgTypes)...), BOOST_THREAD_FWD_REF(ArgTypes)... args) { |
| typedef R(*F)(BOOST_THREAD_FWD_REF(ArgTypes)...); |
| typedef detail::invoker<typename decay<F>::type, typename decay<ArgTypes>::type...> BF; |
| typedef typename BF::result_type Rp; |
| |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| f |
| , thread_detail::decay_copy(boost::forward<ArgTypes>(args))... |
| ) |
| )); |
| } |
| #endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| |
| template <class Executor, class F, class ...ArgTypes> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type( |
| typename decay<ArgTypes>::type... |
| )>::type> |
| async(Executor& ex, BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(ArgTypes)... args) { |
| typedef detail::invoker<typename decay<F>::type, typename decay<ArgTypes>::type...> BF; |
| typedef typename BF::result_type Rp; |
| |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| thread_detail::decay_copy(boost::forward<F>(f)) |
| , thread_detail::decay_copy(boost::forward<ArgTypes>(args))... |
| ) |
| )); |
| } |
| |
| #else // ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| #if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| |
| template <class Executor, class R> |
| BOOST_THREAD_FUTURE<R> |
| async(Executor& ex, R(*f)()) { |
| typedef R(*F)(); |
| typedef detail::invoker<F> BF; |
| typedef typename BF::result_type Rp; |
| |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| f |
| ) |
| )); |
| } |
| |
| template <class Executor, class R, class A1> |
| BOOST_THREAD_FUTURE<R> |
| async(Executor& ex, R(*f)(BOOST_THREAD_FWD_REF(A1)), BOOST_THREAD_FWD_REF(A1) a1) { |
| typedef R(*F)(BOOST_THREAD_FWD_REF(A1)); |
| typedef detail::invoker<F, typename decay<A1>::type> BF; |
| typedef typename BF::result_type Rp; |
| |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| f |
| , thread_detail::decay_copy(boost::forward<A1>(a1)) |
| ) |
| )); |
| } |
| #endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| |
| template <class Executor, class F> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type()>::type> |
| async(Executor& ex, BOOST_THREAD_FWD_REF(F) f) { |
| typedef detail::invoker<typename decay<F>::type> BF; |
| typedef typename BF::result_type Rp; |
| |
| return boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| thread_detail::decay_copy(boost::forward<F>(f)) |
| ) |
| ); |
| } |
| |
| template <class Executor, class F, class A1> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type( |
| typename decay<A1>::type |
| )>::type> |
| async(Executor& ex, BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) { |
| typedef detail::invoker<typename decay<F>::type, typename decay<A1>::type> BF; |
| typedef typename BF::result_type Rp; |
| |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| thread_detail::decay_copy(boost::forward<F>(f)) |
| , thread_detail::decay_copy(boost::forward<A1>(a1)) |
| ) |
| )); |
| } |
| |
| template <class Executor, class F, class A1, class A2> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type( |
| typename decay<A1>::type, typename decay<A2>::type |
| )>::type> |
| async(Executor& ex, BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2) { |
| typedef detail::invoker<typename decay<F>::type, typename decay<A1>::type, typename decay<A2>::type> BF; |
| typedef typename BF::result_type Rp; |
| |
| return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_executor_shared_state<Rp>(ex, |
| BF( |
| thread_detail::decay_copy(boost::forward<F>(f)) |
| , thread_detail::decay_copy(boost::forward<A1>(a1)) |
| , thread_detail::decay_copy(boost::forward<A2>(a2)) |
| ) |
| )); |
| } |
| |
| #endif //! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| #endif |
| |
| //////////////////////////////// |
| // template <class F, class... ArgTypes> |
| // future<R> async(F&&, ArgTypes&&...); |
| //////////////////////////////// |
| |
| #if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template <class R, class... ArgTypes> |
| BOOST_THREAD_FUTURE<R> |
| async(R(*f)(BOOST_THREAD_FWD_REF(ArgTypes)...), BOOST_THREAD_FWD_REF(ArgTypes)... args) { |
| return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), f, boost::forward<ArgTypes>(args)...)); |
| } |
| #else |
| template <class R> |
| BOOST_THREAD_FUTURE<R> |
| async(R(*f)()) { |
| return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), f)); |
| } |
| #endif |
| #endif |
| |
| #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) |
| template <class F, class ...ArgTypes> |
| BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type( |
| typename decay<ArgTypes>::type... |
| )>::type> |
| async(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(ArgTypes)... args) { |
| return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), boost::forward<F>(f), boost::forward<ArgTypes>(args)...)); |
| } |
| #else |
| template <class F> |
| BOOST_THREAD_FUTURE<typename boost::result_of<F()>::type> |
| async(BOOST_THREAD_FWD_REF(F) f) { |
| return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), boost::forward<F>(f))); |
| } |
| #endif |
| |
| //////////////////////////////// |
| // make_future deprecated |
| //////////////////////////////// |
| template <typename T> |
| BOOST_THREAD_FUTURE<typename decay<T>::type> make_future(BOOST_THREAD_FWD_REF(T) value) { |
| typedef typename decay<T>::type future_value_type; |
| promise<future_value_type> p; |
| p.set_value(boost::forward<future_value_type>(value)); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| #if defined BOOST_THREAD_USES_MOVE |
| inline BOOST_THREAD_FUTURE<void> make_future() { |
| promise<void> p; |
| p.set_value(); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| #endif |
| |
| //////////////////////////////// |
| // make_ready_future |
| //////////////////////////////// |
| namespace detail { |
| template <class T> |
| struct deduced_type_impl |
| { |
| typedef T type; |
| }; |
| |
| template <class T> |
| struct deduced_type_impl<reference_wrapper<T> const> |
| { |
| typedef T& type; |
| }; |
| template <class T> |
| struct deduced_type_impl<reference_wrapper<T> > |
| { |
| typedef T& type; |
| }; |
| #if __cplusplus > 201103L |
| template <class T> |
| struct deduced_type_impl<std::reference_wrapper<T> > |
| { |
| typedef T& type; |
| }; |
| #endif |
| template <class T> |
| struct deduced_type |
| { |
| typedef typename detail::deduced_type_impl<typename decay<T>::type>::type type; |
| }; |
| |
| } |
| |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template <int = 0, int..., class T> |
| #else |
| template <class T> |
| #endif |
| BOOST_THREAD_FUTURE<typename detail::deduced_type<T>::type> make_ready_future(BOOST_THREAD_FWD_REF(T) value) { |
| typedef typename detail::deduced_type<T>::type future_value_type; |
| promise<future_value_type> p; |
| p.set_value(boost::forward<T>(value)); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| // explicit overloads |
| template <class T> |
| BOOST_THREAD_FUTURE<T> make_ready_future(typename remove_reference<T>::type & x) |
| { |
| promise<T> p; |
| p.set_value(x); |
| return p.get_future(); |
| } |
| |
| template <class T> |
| BOOST_THREAD_FUTURE<T> make_ready_future(BOOST_THREAD_FWD_REF(typename remove_reference<T>::type) x) |
| { |
| promise<T> p; |
| p.set_value(forward<typename remove_reference<T>::type>(x)); |
| return p.get_future(); |
| } |
| |
| // variadic overload |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template <class T, class ...Args> |
| BOOST_THREAD_FUTURE<T> make_ready_future(Args&&... args) |
| { |
| promise<T> p; |
| p.emplace(forward<Args>(args)...); |
| return p.get_future(); |
| |
| } |
| #endif |
| |
| template <typename T, typename T1> |
| BOOST_THREAD_FUTURE<T> make_ready_no_decay_future(T1 value) { |
| typedef T future_value_type; |
| promise<future_value_type> p; |
| p.set_value(value); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined BOOST_THREAD_USES_MOVE |
| inline BOOST_THREAD_FUTURE<void> make_ready_future() { |
| promise<void> p; |
| p.set_value(); |
| return p.get_future(); |
| } |
| #endif |
| |
| template <typename T> |
| BOOST_THREAD_FUTURE<T> make_ready_future(exception_ptr ex) { |
| promise<T> p; |
| p.set_exception(ex); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| template <typename T> |
| BOOST_THREAD_FUTURE<T> make_exceptional_future(exception_ptr ex) { |
| promise<T> p; |
| p.set_exception(ex); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| template <typename T, typename E> |
| BOOST_THREAD_FUTURE<T> make_exceptional_future(E ex) { |
| promise<T> p; |
| p.set_exception(boost::copy_exception(ex)); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| template <typename T> |
| BOOST_THREAD_FUTURE<T> make_exceptional_future() { |
| promise<T> p; |
| p.set_exception(boost::current_exception()); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| |
| template <typename T> |
| BOOST_THREAD_FUTURE<T> make_exceptional_future_if_invalid(BOOST_THREAD_FWD_REF(BOOST_THREAD_FUTURE<T>) fut) { |
| fut.set_exceptional_if_invalid(); |
| return boost::move(fut); |
| } |
| template <typename T> |
| shared_future<T> make_exceptional_future_if_invalid(shared_future<T> fut) { |
| fut.set_exceptional_if_invalid(); |
| return fut; |
| } |
| |
| #if 0 |
| template<typename CLOSURE> |
| make_future(CLOSURE closure) -> BOOST_THREAD_FUTURE<decltype(closure())> { |
| typedef decltype(closure()) T; |
| promise<T> p; |
| try { |
| p.set_value(closure()); |
| } catch(...) { |
| p.set_exception(std::current_exception()); |
| } |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future()); |
| } |
| #endif |
| |
| //////////////////////////////// |
| // make_shared_future deprecated |
| //////////////////////////////// |
| template <typename T> |
| shared_future<typename decay<T>::type> make_shared_future(BOOST_THREAD_FWD_REF(T) value) { |
| typedef typename decay<T>::type future_type; |
| promise<future_type> p; |
| p.set_value(boost::forward<T>(value)); |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future().share()); |
| } |
| |
| inline shared_future<void> make_shared_future() { |
| promise<void> p; |
| return BOOST_THREAD_MAKE_RV_REF(p.get_future().share()); |
| } |
| |
| //////////////////////////////// |
| // detail::future_async_continuation_shared_state |
| //////////////////////////////// |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| namespace detail |
| { |
| |
| ///////////////////////// |
| /// future_async_continuation_shared_state |
| ///////////////////////// |
| |
| template<typename F, typename Rp, typename Fp> |
| struct future_async_continuation_shared_state: future_async_shared_state_base<Rp> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| future_async_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(boost::move(f)), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| } |
| |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>&, shared_ptr<shared_state_base> that) { |
| this->thr_ = thread(&future_async_continuation_shared_state::run, that); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| future_async_continuation_shared_state* that = dynamic_cast<future_async_continuation_shared_state*>(that_.get()); |
| try { |
| that->mark_finished_with_result(that->continuation(boost::move(that->parent))); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| ~future_async_continuation_shared_state() { |
| } |
| }; |
| |
| template<typename F, typename Fp> |
| struct future_async_continuation_shared_state<F, void, Fp>: public future_async_shared_state_base<void> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| future_async_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(boost::move(f)), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>&, shared_ptr<shared_state_base> that) { |
| this->thr_ = thread(&future_async_continuation_shared_state::run, that); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| future_async_continuation_shared_state* that = dynamic_cast<future_async_continuation_shared_state*>(that_.get()); |
| try { |
| that->continuation(boost::move(that->parent)); |
| that->mark_finished_with_result(); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| ~future_async_continuation_shared_state() {} |
| |
| }; |
| |
| ///////////////////////// |
| /// future_executor_continuation_shared_state |
| ///////////////////////// |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| |
| template <typename FutureExecutorContinuationSharedState> |
| struct run_it { |
| shared_ptr<boost::detail::shared_state_base> that_; |
| |
| run_it(shared_ptr<boost::detail::shared_state_base> that) : that_ (that) {} |
| void operator()() |
| { |
| FutureExecutorContinuationSharedState* that = dynamic_cast<FutureExecutorContinuationSharedState*>(that_.get()); |
| that->run(that_); |
| } |
| }; |
| |
| template<typename Ex, typename F, typename Rp, typename Fp> |
| struct future_executor_continuation_shared_state: shared_state<Rp> |
| { |
| Ex* ex; |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| future_executor_continuation_shared_state(Ex& ex, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
| : ex(&ex), parent(boost::move(f)), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_executor(); |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>& lck, shared_ptr<shared_state_base> that ) { |
| relocker relock(lck); |
| run_it<future_executor_continuation_shared_state> fct(that); |
| ex->submit(fct); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| future_executor_continuation_shared_state* that = dynamic_cast<future_executor_continuation_shared_state*>(that_.get()); |
| try { |
| that->mark_finished_with_result(that->continuation(boost::move(that->parent))); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>&lk) |
| { |
| this->wait(lk, false); |
| } |
| |
| ~future_executor_continuation_shared_state() {} |
| }; |
| |
| template<typename Ex, typename F, typename Fp> |
| struct future_executor_continuation_shared_state<Ex, F, void, Fp>: public shared_state<void> |
| { |
| Ex* ex; |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| future_executor_continuation_shared_state(Ex& ex, BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
| : ex(&ex), parent(boost::move(f)), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_executor(); |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>& lck, shared_ptr<shared_state_base> that ) { |
| relocker relock(lck); |
| run_it<future_executor_continuation_shared_state> fct(that); |
| ex->submit(fct); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| future_executor_continuation_shared_state* that = dynamic_cast<future_executor_continuation_shared_state*>(that_.get()); |
| try { |
| that->continuation(boost::move(that->parent)); |
| that->mark_finished_with_result(); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>&lk) |
| { |
| this->wait(lk, false); |
| } |
| |
| ~future_executor_continuation_shared_state() {} |
| }; |
| #endif |
| |
| ///////////////////////// |
| /// shared_future_async_continuation_shared_state |
| ///////////////////////// |
| |
| template<typename F, typename Rp, typename Fp> |
| struct shared_future_async_continuation_shared_state: future_async_shared_state_base<Rp> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| shared_future_async_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(f), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>&, shared_ptr<shared_state_base> that) { |
| this->thr_ = thread(&shared_future_async_continuation_shared_state::run, that); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| shared_future_async_continuation_shared_state* that = dynamic_cast<shared_future_async_continuation_shared_state*>(that_.get()); |
| try { |
| that->mark_finished_with_result(that->continuation(that->parent)); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| ~shared_future_async_continuation_shared_state() {} |
| }; |
| |
| template<typename F, typename Fp> |
| struct shared_future_async_continuation_shared_state<F, void, Fp>: public future_async_shared_state_base<void> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| shared_future_async_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(f), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>&, shared_ptr<shared_state_base> that) { |
| this->thr_ = thread(&shared_future_async_continuation_shared_state::run, that); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| shared_future_async_continuation_shared_state* that = dynamic_cast<shared_future_async_continuation_shared_state*>(that_.get()); |
| try { |
| that->continuation(that->parent); |
| that->mark_finished_with_result(); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| ~shared_future_async_continuation_shared_state() {} |
| }; |
| |
| ///////////////////////// |
| /// shared_future_executor_continuation_shared_state |
| ///////////////////////// |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| |
| template<typename Ex, typename F, typename Rp, typename Fp> |
| struct shared_future_executor_continuation_shared_state: shared_state<Rp> |
| { |
| Ex* ex; |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| shared_future_executor_continuation_shared_state(Ex& ex, F f, BOOST_THREAD_FWD_REF(Fp) c) |
| : ex(&ex), parent(f), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_executor(); |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>& lck, shared_ptr<shared_state_base> that) { |
| relocker relock(lck); |
| run_it<shared_future_executor_continuation_shared_state> fct(that); |
| ex->submit(fct); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| shared_future_executor_continuation_shared_state* that = dynamic_cast<shared_future_executor_continuation_shared_state*>(that_.get()); |
| try { |
| that->mark_finished_with_result(that->continuation(that->parent)); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>&lk) |
| { |
| this->wait(lk, false); |
| } |
| |
| ~shared_future_executor_continuation_shared_state() {} |
| }; |
| |
| template<typename Ex, typename F, typename Fp> |
| struct shared_future_executor_continuation_shared_state<Ex, F, void, Fp>: public shared_state<void> |
| { |
| Ex* ex; |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| shared_future_executor_continuation_shared_state(Ex& ex, F f, BOOST_THREAD_FWD_REF(Fp) c) |
| : ex(&ex), parent(f), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| } |
| |
| void launch_continuation(boost::unique_lock<boost::mutex>& lck, shared_ptr<shared_state_base> that) { |
| relocker relock(lck); |
| run_it<shared_future_executor_continuation_shared_state> fct(that); |
| ex->submit(fct); |
| } |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| shared_future_executor_continuation_shared_state* that = dynamic_cast<shared_future_executor_continuation_shared_state*>(that_.get()); |
| try { |
| that->continuation(that->parent); |
| that->mark_finished_with_result(); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| virtual void block_if_needed(boost::unique_lock<boost::mutex>&lk) |
| { |
| this->wait(lk, false); |
| } |
| |
| ~shared_future_executor_continuation_shared_state() {} |
| }; |
| #endif |
| ////////////////////////// |
| /// future_deferred_continuation_shared_state |
| ////////////////////////// |
| template<typename F, typename Rp, typename Fp> |
| struct future_deferred_continuation_shared_state: shared_state<Rp> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| future_deferred_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(boost::move(f)), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_deferred(); |
| } |
| |
| virtual void launch_continuation(boost::unique_lock<boost::mutex>&lk, shared_ptr<shared_state_base> ) { |
| if (this->is_deferred_) { |
| this->is_deferred_=false; |
| this->execute(lk); |
| } |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try { |
| Fp local_fuct=boost::move(continuation); |
| F ftmp = boost::move(parent); |
| relocker relock(lck); |
| Rp res = local_fuct(boost::move(ftmp)); |
| relock.lock(); |
| this->mark_finished_with_result_internal(boost::move(res), lck); |
| } catch (...) { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| |
| template<typename F, typename Fp> |
| struct future_deferred_continuation_shared_state<F,void,Fp>: shared_state<void> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| future_deferred_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(boost::move(f)), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_deferred(); |
| } |
| |
| ~future_deferred_continuation_shared_state() { |
| } |
| virtual void launch_continuation(boost::unique_lock<boost::mutex>& lk, shared_ptr<shared_state_base> ) { |
| if (this->is_deferred_) { |
| this->is_deferred_=false; |
| this->execute(lk); |
| } |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try { |
| Fp local_fuct=boost::move(continuation); |
| F ftmp = boost::move(parent); |
| relocker relock(lck); |
| local_fuct(boost::move(ftmp)); |
| relock.lock(); |
| this->mark_finished_with_result_internal(lck); |
| } catch (...) { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| |
| ////////////////////////// |
| /// shared_future_deferred_continuation_shared_state |
| ////////////////////////// |
| template<typename F, typename Rp, typename Fp> |
| struct shared_future_deferred_continuation_shared_state: shared_state<Rp> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| shared_future_deferred_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(f), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_deferred(); |
| } |
| |
| virtual void launch_continuation(boost::unique_lock<boost::mutex>& lk, shared_ptr<shared_state_base> ) { |
| if (this->is_deferred_) { |
| this->is_deferred_=false; |
| this->execute(lk); |
| } |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try { |
| Fp local_fuct=boost::move(continuation); |
| F ftmp = parent; |
| relocker relock(lck); |
| Rp res = local_fuct(ftmp); |
| relock.lock(); |
| this->mark_finished_with_result_internal(boost::move(res), lck); |
| } catch (...) { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| |
| template<typename F, typename Fp> |
| struct shared_future_deferred_continuation_shared_state<F,void,Fp>: shared_state<void> |
| { |
| F parent; |
| Fp continuation; |
| shared_ptr<shared_state_base> centinel; |
| |
| public: |
| shared_future_deferred_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
| : parent(f), |
| continuation(boost::move(c)), |
| centinel(parent.future_) { |
| this->set_deferred(); |
| } |
| |
| virtual void launch_continuation(boost::unique_lock<boost::mutex>& lk, shared_ptr<shared_state_base> ) { |
| if (this->is_deferred_) { |
| this->is_deferred_=false; |
| this->execute(lk); |
| } |
| } |
| |
| virtual void execute(boost::unique_lock<boost::mutex>& lck) { |
| try { |
| Fp local_fuct=boost::move(continuation); |
| F ftmp = parent; |
| relocker relock(lck); |
| local_fuct(ftmp); |
| relock.lock(); |
| this->mark_finished_with_result_internal(lck); |
| } catch (...) { |
| this->mark_exceptional_finish_internal(current_exception(), lck); |
| } |
| } |
| }; |
| |
| //////////////////////////////// |
| // make_future_deferred_continuation_shared_state |
| //////////////////////////////// |
| template<typename F, typename Rp, typename Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_deferred_continuation_shared_state( |
| boost::unique_lock<boost::mutex> &lock, |
| BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) { |
| shared_ptr<future_deferred_continuation_shared_state<F, Rp, Fp> > |
| h(new future_deferred_continuation_shared_state<F, Rp, Fp>(boost::move(f), boost::forward<Fp>(c))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| |
| //////////////////////////////// |
| // make_future_async_continuation_shared_state |
| //////////////////////////////// |
| template<typename F, typename Rp, typename Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_async_continuation_shared_state( |
| boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, |
| BOOST_THREAD_FWD_REF(Fp) c) { |
| shared_ptr<future_async_continuation_shared_state<F,Rp, Fp> > |
| h(new future_async_continuation_shared_state<F,Rp, Fp>(boost::move(f), boost::forward<Fp>(c))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| |
| //////////////////////////////// |
| // make_future_executor_continuation_shared_state |
| //////////////////////////////// |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| |
| template<typename Ex, typename F, typename Rp, typename Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_executor_continuation_shared_state(Ex& ex, |
| boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, |
| BOOST_THREAD_FWD_REF(Fp) c) { |
| shared_ptr<future_executor_continuation_shared_state<Ex,F,Rp, Fp> > |
| h(new future_executor_continuation_shared_state<Ex, F,Rp, Fp>(ex, boost::move(f), boost::forward<Fp>(c))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| #endif |
| |
| //////////////////////////////// |
| // make_shared_future_deferred_continuation_shared_state |
| //////////////////////////////// |
| template<typename F, typename Rp, typename Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_shared_future_deferred_continuation_shared_state( |
| boost::unique_lock<boost::mutex> &lock, |
| F f, BOOST_THREAD_FWD_REF(Fp) c) { |
| shared_ptr<shared_future_deferred_continuation_shared_state<F, Rp, Fp> > |
| h(new shared_future_deferred_continuation_shared_state<F, Rp, Fp>(f, boost::forward<Fp>(c))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| //////////////////////////////// |
| // make_shared_future_async_continuation_shared_state |
| //////////////////////////////// |
| template<typename F, typename Rp, typename Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_shared_future_async_continuation_shared_state( |
| boost::unique_lock<boost::mutex> &lock, F f, |
| BOOST_THREAD_FWD_REF(Fp) c) { |
| shared_ptr<shared_future_async_continuation_shared_state<F,Rp, Fp> > |
| h(new shared_future_async_continuation_shared_state<F,Rp, Fp>(f, boost::forward<Fp>(c))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| //////////////////////////////// |
| // make_shared_future_executor_continuation_shared_state |
| //////////////////////////////// |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template<typename Ex, typename F, typename Rp, typename Fp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_shared_future_executor_continuation_shared_state(Ex& ex, |
| boost::unique_lock<boost::mutex> &lock, F f, |
| BOOST_THREAD_FWD_REF(Fp) c) { |
| shared_ptr<shared_future_executor_continuation_shared_state<Ex, F, Rp, Fp> > |
| h(new shared_future_executor_continuation_shared_state<Ex, F, Rp, Fp>(ex, f, boost::forward<Fp>(c))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| #endif |
| } |
| |
| //////////////////////////////// |
| // template<typename F> |
| // auto future<R>::then(F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>; |
| //////////////////////////////// |
| |
| template <typename R> |
| template <typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type> |
| BOOST_THREAD_FUTURE<R>::then(launch policy, BOOST_THREAD_FWD_REF(F) func) { |
| typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| this->future_->wait_internal(lock); |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_deferred_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } else { |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } |
| } |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template <typename R> |
| template <typename Ex, typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type> |
| BOOST_THREAD_FUTURE<R>::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) { |
| typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type, F>(ex, |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } |
| #endif |
| template <typename R> |
| template <typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type> |
| BOOST_THREAD_FUTURE<R>::then(BOOST_THREAD_FWD_REF(F) func) { |
| typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| if (underlying_cast<int>(this->launch_policy(lock)) & int(launch::async)) { |
| lock.unlock(); |
| return boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ); |
| } else if (underlying_cast<int>(this->launch_policy(lock)) & int(launch::deferred)) { |
| this->future_->wait_internal(lock); |
| lock.unlock(); |
| return boost::detail::make_future_deferred_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ); |
| } else { |
| lock.unlock(); |
| return boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ); |
| } |
| } |
| |
| //////////////////////////////// |
| // template<typename F> |
| // auto future<future<R2>>::then(F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>; |
| //////////////////////////////// |
| |
| template <typename R2> |
| template <typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >)>::type> |
| BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(launch policy, BOOST_THREAD_FWD_REF(F) func) { |
| typedef BOOST_THREAD_FUTURE<R2> R; |
| typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_deferred_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } else { |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } |
| } |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template <typename R2> |
| template <typename Ex, typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >)>::type> |
| BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) { |
| typedef BOOST_THREAD_FUTURE<R2> R; |
| typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type, F>(ex, |
| lock, boost::move(*this), boost::forward<F>(func) |
| ))); |
| } |
| #endif |
| template <typename R2> |
| template <typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >)>::type> |
| BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(BOOST_THREAD_FWD_REF(F) func) { |
| typedef BOOST_THREAD_FUTURE<R2> R; |
| typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| if (underlying_cast<int>(this->launch_policy(lock)) & int(launch::async)) { |
| return boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ); |
| } else if (underlying_cast<int>(this->launch_policy(lock)) & int(launch::deferred)) { |
| this->future_->wait_internal(lock); |
| return boost::detail::make_future_deferred_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ); |
| } else { |
| return boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type, F>( |
| lock, boost::move(*this), boost::forward<F>(func) |
| ); |
| } |
| } |
| |
| //////////////////////////////// |
| // template<typename F> |
| // auto shared_future<R>::then(F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>; |
| //////////////////////////////// |
| |
| template <typename R> |
| template <typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(shared_future<R>)>::type> |
| shared_future<R>::then(launch policy, BOOST_THREAD_FWD_REF(F) func) const |
| { |
| typedef typename boost::result_of<F(shared_future<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| if (underlying_cast<int>(policy) & int(launch::async)) { |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type, F>( |
| lock, *this, boost::forward<F>(func) |
| ))); |
| } else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
| this->future_->wait_internal(lock); |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_deferred_continuation_shared_state<shared_future<R>, future_type, F>( |
| lock, *this, boost::forward<F>(func) |
| ))); |
| } else { |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type, F>( |
| lock, *this, boost::forward<F>(func) |
| ))); |
| } |
| } |
| #ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
| template <typename R> |
| template <typename Ex, typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(shared_future<R>)>::type> |
| shared_future<R>::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) const |
| { |
| typedef typename boost::result_of<F(shared_future<R>)>::type future_type; |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| lock.unlock(); |
| return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_executor_continuation_shared_state<Ex, shared_future<R>, future_type, F>(ex, |
| lock, *this, boost::forward<F>(func) |
| ))); |
| } |
| #endif |
| |
| template <typename R> |
| template <typename F> |
| inline BOOST_THREAD_FUTURE<typename boost::result_of<F(shared_future<R>)>::type> |
| shared_future<R>::then(BOOST_THREAD_FWD_REF(F) func) const { |
| typedef typename boost::result_of<F(shared_future<R>)>::type future_type; |
| |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| if (underlying_cast<int>(this->launch_policy(lock)) & int(launch::async)) { |
| lock.unlock(); |
| return boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type, F>( |
| lock, *this, boost::forward<F>(func)); |
| } else if (underlying_cast<int>(this->launch_policy(lock)) & int(launch::deferred)) { |
| this->future_->wait_internal(lock); |
| lock.unlock(); |
| return boost::detail::make_shared_future_deferred_continuation_shared_state<shared_future<R>, future_type, F>( |
| lock, *this, boost::forward<F>(func)); |
| } else { |
| lock.unlock(); |
| return boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type, F>( |
| lock, *this, boost::forward<F>(func)); |
| } |
| } |
| |
| namespace detail |
| { |
| template <typename T> |
| struct mfallbacker_to |
| { |
| T value_; |
| typedef T result_type; |
| mfallbacker_to(BOOST_THREAD_RV_REF(T) v) |
| : value_(boost::move(v)) |
| {} |
| |
| T operator()(BOOST_THREAD_FUTURE<T> fut) { |
| return fut.get_or(boost::move(value_)); |
| } |
| }; |
| template <typename T> |
| struct cfallbacker_to |
| { |
| T value_; |
| typedef T result_type; |
| cfallbacker_to(T const& v) |
| : value_(v) |
| {} |
| |
| T operator()(BOOST_THREAD_FUTURE<T> fut) const { |
| return fut.get_or(value_); |
| |
| } |
| }; |
| } |
| //////////////////////////////// |
| // future<R> future<R>::fallback_to(R&& v); |
| //////////////////////////////// |
| |
| template <typename R> |
| template <typename R2> |
| inline typename boost::disable_if< is_void<R2>, BOOST_THREAD_FUTURE<R> >::type |
| BOOST_THREAD_FUTURE<R>::fallback_to(BOOST_THREAD_RV_REF(R2) v) { |
| return then(detail::mfallbacker_to<R>(boost::move(v))); |
| } |
| |
| template <typename R> |
| template <typename R2> |
| inline typename boost::disable_if< is_void<R2>, BOOST_THREAD_FUTURE<R> >::type |
| BOOST_THREAD_FUTURE<R>::fallback_to(R2 const& v) { |
| return then(detail::cfallbacker_to<R>(v)); |
| } |
| |
| #endif |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP |
| namespace detail |
| { |
| ///////////////////////// |
| /// future_unwrap_shared_state |
| ///////////////////////// |
| |
| template<typename F, typename Rp> |
| struct future_unwrap_shared_state: shared_state<Rp> |
| { |
| F parent; |
| public: |
| explicit future_unwrap_shared_state(BOOST_THREAD_RV_REF(F) f) |
| : parent(boost::move(f)) {} |
| |
| typename F::value_type parent_value(boost::unique_lock<boost::mutex>& ) { |
| typename F::value_type r = parent.get(); |
| r.set_exceptional_if_invalid(); |
| return boost::move(r); |
| } |
| |
| virtual void wait(boost::unique_lock<boost::mutex>& lk, bool ) { // todo see if rethrow must be used |
| parent_value(lk).wait(); |
| } |
| virtual Rp get(boost::unique_lock<boost::mutex>& lk) { |
| return parent_value(lk).get(); |
| } |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
| typedef shared_ptr<shared_state_base> continuation_ptr_type; |
| |
| virtual void set_continuation_ptr(continuation_ptr_type continuation, boost::unique_lock<boost::mutex>& lock) |
| { |
| boost::unique_lock<boost::mutex> lk(parent.future_->mutex); |
| parent.future_->set_continuation_ptr(continuation, lk); |
| } |
| #endif |
| }; |
| |
| template <class F, class Rp> |
| BOOST_THREAD_FUTURE<Rp> |
| make_future_unwrap_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f) { |
| shared_ptr<future_unwrap_shared_state<F, Rp> > |
| h(new future_unwrap_shared_state<F, Rp>(boost::move(f))); |
| lock.lock(); |
| h->parent.future_->set_continuation_ptr(h, lock); |
| lock.unlock(); |
| return BOOST_THREAD_FUTURE<Rp>(h); |
| } |
| } |
| |
| template <typename R> |
| inline BOOST_THREAD_FUTURE<R>::BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R> >) other) |
| : base_type(other.unwrap()) {} |
| |
| template <typename R2> |
| BOOST_THREAD_FUTURE<R2> |
| BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::unwrap() |
| { |
| BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized()); |
| boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
| lock.unlock(); |
| return boost::detail::make_future_unwrap_shared_state<BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >, R2>(lock, boost::move(*this)); |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY |
| namespace detail |
| { |
| struct input_iterator_tag {}; |
| struct vector_tag {}; |
| struct values_tag {}; |
| template <typename T> |
| struct alias_t { typedef T type; }; |
| |
| BOOST_CONSTEXPR_OR_CONST input_iterator_tag input_iterator_tag_value = {}; |
| BOOST_CONSTEXPR_OR_CONST vector_tag vector_tag_value = {}; |
| BOOST_CONSTEXPR_OR_CONST values_tag values_tag_value = {}; |
| //////////////////////////////// |
| // detail::future_async_when_all_shared_state |
| //////////////////////////////// |
| template<typename F> |
| struct future_when_all_vector_shared_state: future_async_shared_state_base<csbl::vector<F> > |
| { |
| typedef csbl::vector<F> vector_type; |
| typedef typename F::value_type value_type; |
| vector_type vec_; |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| future_when_all_vector_shared_state* that = dynamic_cast<future_when_all_vector_shared_state*>(that_.get()); |
| try { |
| boost::wait_for_all(that->vec_.begin(), that->vec_.end()); |
| that->mark_finished_with_result(boost::move(that->vec_)); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| bool run_deferred() { |
| |
| bool res = false; |
| for (typename csbl::vector<F>::iterator it = vec_.begin(); it != vec_.end(); ++it) { |
| if (! it->run_if_is_deferred()) |
| { |
| res = true; |
| } |
| } |
| return res; |
| } |
| void init() { |
| if (! run_deferred()) |
| { |
| future_when_all_vector_shared_state::run(this->shared_from_this()); |
| return; |
| } |
| this->thr_ = thread(&future_when_all_vector_shared_state::run, this->shared_from_this()); |
| } |
| |
| public: |
| template< typename InputIterator> |
| future_when_all_vector_shared_state(input_iterator_tag, InputIterator first, InputIterator last) |
| : vec_(std::make_move_iterator(first), std::make_move_iterator(last)) |
| { |
| } |
| |
| future_when_all_vector_shared_state(vector_tag, BOOST_THREAD_RV_REF(csbl::vector<F>) v) |
| : vec_(boost::move(v)) |
| { |
| } |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template< typename T0, typename ...T> |
| future_when_all_vector_shared_state(values_tag, BOOST_THREAD_FWD_REF(T0) f, BOOST_THREAD_FWD_REF(T) ... futures) { |
| vec_.push_back(boost::forward<T0>(f)); |
| typename alias_t<char[]>::type{ |
| ( //first part of magic unpacker |
| vec_.push_back(boost::forward<T>(futures)),'0' |
| )..., '0' |
| }; //second part of magic unpacker |
| } |
| #endif |
| |
| ~future_when_all_vector_shared_state() {} |
| }; |
| |
| //////////////////////////////// |
| // detail::future_async_when_any_shared_state |
| //////////////////////////////// |
| template<typename F> |
| struct future_when_any_vector_shared_state: future_async_shared_state_base<csbl::vector<F> > |
| { |
| typedef csbl::vector<F> vector_type; |
| typedef typename F::value_type value_type; |
| vector_type vec_; |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) |
| { |
| future_when_any_vector_shared_state* that = dynamic_cast<future_when_any_vector_shared_state*>(that_.get()); |
| try { |
| boost::wait_for_any(that->vec_.begin(), that->vec_.end()); |
| that->mark_finished_with_result(boost::move(that->vec_)); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| bool run_deferred() { |
| |
| for (typename csbl::vector<F>::iterator it = vec_.begin(); it != vec_.end(); ++it) { |
| if (it->run_if_is_deferred_or_ready()) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| void init() { |
| if (run_deferred()) |
| { |
| future_when_any_vector_shared_state::run(this->shared_from_this()); |
| return; |
| } |
| |
| this->thr_ = thread(&future_when_any_vector_shared_state::run, this->shared_from_this()); |
| } |
| |
| public: |
| template< typename InputIterator> |
| future_when_any_vector_shared_state(input_iterator_tag, InputIterator first, InputIterator last) |
| : vec_(std::make_move_iterator(first), std::make_move_iterator(last)) |
| { |
| } |
| |
| future_when_any_vector_shared_state(vector_tag, BOOST_THREAD_RV_REF(csbl::vector<F>) v) |
| : vec_(boost::move(v)) |
| { |
| } |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template< typename T0, typename ...T> |
| future_when_any_vector_shared_state(values_tag, |
| BOOST_THREAD_FWD_REF(T0) f, BOOST_THREAD_FWD_REF(T) ... futures |
| ) { |
| vec_.push_back(boost::forward<T0>(f)); |
| typename alias_t<char[]>::type{ |
| ( //first part of magic unpacker |
| vec_.push_back(boost::forward<T>(futures)) |
| ,'0' |
| )..., |
| '0' |
| }; //second part of magic unpacker |
| } |
| #endif |
| |
| ~future_when_any_vector_shared_state() {} |
| }; |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| struct wait_for_all_fctr { |
| template <class ...T> |
| void operator()(T&&... v) { |
| boost::wait_for_all(boost::forward<T>(v)...); |
| } |
| }; |
| |
| struct wait_for_any_fctr { |
| template <class ...T> |
| void operator()(T&&... v) { |
| boost::wait_for_any(boost::forward<T>(v)...); |
| } |
| }; |
| |
| |
| template <class Tuple, std::size_t i=csbl::tuple_size<Tuple>::value> |
| struct accumulate_run_if_is_deferred { |
| bool operator ()(Tuple& t) |
| { |
| return (! csbl::get<i-1>(t).run_if_is_deferred()) || accumulate_run_if_is_deferred<Tuple,i-1>()(t); |
| } |
| }; |
| template <class Tuple> |
| struct accumulate_run_if_is_deferred<Tuple, 0> { |
| bool operator ()(Tuple& ) |
| { |
| return false; |
| } |
| }; |
| |
| |
| template< typename Tuple, typename T0, typename ...T> |
| struct future_when_all_tuple_shared_state: future_async_shared_state_base<Tuple> |
| { |
| Tuple tup_; |
| typedef typename make_tuple_indices<1+sizeof...(T)>::type Index; |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) { |
| future_when_all_tuple_shared_state* that = dynamic_cast<future_when_all_tuple_shared_state*>(that_.get()); |
| try { |
| // TODO make use of apply(that->tup_, boost::detail::wait_for_all_fctor()); |
| that->wait_for_all(Index()); |
| |
| that->mark_finished_with_result(boost::move(that->tup_)); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| |
| template <size_t ...Indices> |
| void wait_for_all(tuple_indices<Indices...>) { |
| #if defined BOOST_THREAD_PROVIDES_INVOKE |
| return invoke<void>(wait_for_all_fctr(), csbl::get<Indices>(tup_)...); |
| #else |
| return wait_for_all_fctr()(csbl::get<Indices>(tup_)...); |
| #endif |
| } |
| |
| bool run_deferred() { |
| |
| return accumulate_run_if_is_deferred<Tuple>()(tup_); |
| } |
| void init() { |
| if (! run_deferred()) |
| { |
| future_when_all_tuple_shared_state::run(this->shared_from_this()); |
| return; |
| } |
| |
| this->thr_ = thread(&future_when_all_tuple_shared_state::run, this->shared_from_this()); |
| } |
| public: |
| template< typename F, typename ...Fs> |
| future_when_all_tuple_shared_state(values_tag, BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Fs) ... futures) : |
| tup_(boost::csbl::make_tuple(boost::forward<F>(f), boost::forward<Fs>(futures)...)) |
| { |
| } |
| |
| ~future_when_all_tuple_shared_state() {} |
| |
| }; |
| |
| |
| template <class Tuple, std::size_t i=csbl::tuple_size<Tuple>::value> |
| struct apply_any_run_if_is_deferred_or_ready { |
| bool operator ()(Tuple& t) |
| { |
| if (csbl::get<i-1>(t).run_if_is_deferred_or_ready()) return true; |
| return apply_any_run_if_is_deferred_or_ready<Tuple,i-1>()(t); |
| } |
| }; |
| template <class Tuple> |
| struct apply_any_run_if_is_deferred_or_ready<Tuple, 0> { |
| bool operator ()(Tuple& ) |
| { |
| return false; |
| } |
| }; |
| |
| template< typename Tuple, typename T0, typename ...T > |
| struct future_when_any_tuple_shared_state: future_async_shared_state_base<Tuple> |
| { |
| Tuple tup_; |
| typedef typename make_tuple_indices<1+sizeof...(T)>::type Index; |
| |
| static void run(shared_ptr<boost::detail::shared_state_base> that_) |
| { |
| future_when_any_tuple_shared_state* that = dynamic_cast<future_when_any_tuple_shared_state*>(that_.get()); |
| try { |
| // TODO make use of apply(that->tup_, wait_for_any_fctr); |
| that->wait_for_any(Index()); |
| |
| that->mark_finished_with_result(boost::move(that->tup_)); |
| } catch(...) { |
| that->mark_exceptional_finish(); |
| } |
| } |
| template <size_t ...Indices> |
| void wait_for_any(tuple_indices<Indices...>) { |
| #if defined BOOST_THREAD_PROVIDES_INVOKE |
| return invoke<void>(wait_for_any_fctr(), csbl::get<Indices>(tup_)...); |
| #else |
| return wait_for_any_fctr()(csbl::get<Indices>(tup_)...); |
| #endif |
| } |
| bool run_deferred() { |
| return apply_any_run_if_is_deferred_or_ready<Tuple>()(tup_); |
| } |
| void init() { |
| if (run_deferred()) |
| { |
| future_when_any_tuple_shared_state::run(this->shared_from_this()); |
| return; |
| } |
| |
| this->thr_ = thread(&future_when_any_tuple_shared_state::run, this->shared_from_this()); |
| } |
| |
| public: |
| template< typename F, typename ...Fs> |
| future_when_any_tuple_shared_state(values_tag, |
| BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Fs) ... futures |
| ) : |
| tup_(boost::csbl::make_tuple(boost::forward<F>(f), boost::forward<Fs>(futures)...)) |
| { |
| } |
| |
| ~future_when_any_tuple_shared_state() {} |
| }; |
| #endif |
| |
| } |
| |
| template< typename InputIterator> |
| typename boost::disable_if<is_future_type<InputIterator>, |
| BOOST_THREAD_FUTURE<csbl::vector<typename InputIterator::value_type> > |
| >::type |
| when_all(InputIterator first, InputIterator last) { |
| typedef typename InputIterator::value_type value_type; |
| typedef csbl::vector<value_type> container_type; |
| typedef detail::future_when_all_vector_shared_state<value_type> factory_type; |
| |
| if (first==last) return make_ready_future(container_type()); |
| shared_ptr<factory_type > |
| h(new factory_type(detail::input_iterator_tag_value, first,last)); |
| h->init(); |
| return BOOST_THREAD_FUTURE<container_type>(h); |
| } |
| |
| inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_all() { |
| return make_ready_future(csbl::tuple<>()); |
| } |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template< typename T0, typename ...T> |
| BOOST_THREAD_FUTURE<csbl::tuple<typename decay<T0>::type, typename decay<T>::type...> > |
| when_all(BOOST_THREAD_FWD_REF(T0) f, BOOST_THREAD_FWD_REF(T) ... futures) { |
| typedef csbl::tuple<typename decay<T0>::type, typename decay<T>::type...> container_type; |
| typedef detail::future_when_all_tuple_shared_state<container_type, typename decay<T0>::type, typename decay<T>::type...> factory_type; |
| |
| shared_ptr<factory_type> |
| h(new factory_type(detail::values_tag_value, boost::forward<T0>(f), boost::forward<T>(futures)...)); |
| h->init(); |
| return BOOST_THREAD_FUTURE<container_type>(h); |
| } |
| #endif |
| |
| template< typename InputIterator> |
| typename boost::disable_if<is_future_type<InputIterator>, |
| BOOST_THREAD_FUTURE<csbl::vector<typename InputIterator::value_type> > |
| >::type |
| when_any(InputIterator first, InputIterator last) { |
| typedef typename InputIterator::value_type value_type; |
| typedef csbl::vector<value_type> container_type; |
| typedef detail::future_when_any_vector_shared_state<value_type> factory_type; |
| |
| if (first==last) return make_ready_future(container_type()); |
| shared_ptr<factory_type > |
| h(new factory_type(detail::input_iterator_tag_value, first,last)); |
| h->init(); |
| return BOOST_THREAD_FUTURE<container_type>(h); |
| } |
| |
| inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_any() { |
| return make_ready_future(csbl::tuple<>()); |
| } |
| |
| #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
| template< typename T0, typename ...T> |
| BOOST_THREAD_FUTURE<csbl::tuple<typename decay<T0>::type, typename decay<T>::type...> > |
| when_any(BOOST_THREAD_FWD_REF(T0) f, BOOST_THREAD_FWD_REF(T) ... futures) { |
| typedef csbl::tuple<typename decay<T0>::type, typename decay<T>::type...> container_type; |
| typedef detail::future_when_any_tuple_shared_state<container_type, typename decay<T0>::type, typename decay<T>::type...> factory_type; |
| |
| shared_ptr<factory_type> |
| h(new factory_type(detail::values_tag_value, boost::forward<T0>(f), boost::forward<T>(futures)...)); |
| h->init(); |
| return BOOST_THREAD_FUTURE<container_type>(h); |
| } |
| #endif |
| #endif // BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY |
| } |
| |
| #endif // BOOST_NO_EXCEPTION |
| #endif // header |