You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5898 lines
199 KiB
5898 lines
199 KiB
// (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 |
|
|
|
//#define BOOST_THREAD_CONTINUATION_SYNC |
|
|
|
#ifdef BOOST_NO_EXCEPTIONS |
|
namespace boost |
|
{ |
|
namespace detail { |
|
struct shared_state_base { |
|
void notify_deferred() {} |
|
}; |
|
} |
|
} |
|
#else |
|
|
|
#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> |
|
#include <boost/thread/executor.hpp> |
|
#include <boost/thread/executors/generic_executor_ref.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/smart_ptr/make_shared.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 |
|
{ |
|
template <class T> |
|
shared_ptr<T> static_shared_from_this(T* that) |
|
{ |
|
return static_pointer_cast<T>(that->shared_from_this()); |
|
} |
|
template <class T> |
|
shared_ptr<T const> static_shared_from_this(T const* that) |
|
{ |
|
return static_pointer_cast<T const>(that->shared_from_this()); |
|
} |
|
|
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
#else |
|
namespace executors { |
|
class executor; |
|
} |
|
using executors::executor; |
|
#endif |
|
typedef shared_ptr<executor> executor_ptr_type; |
|
|
|
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; |
|
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; |
|
executor_ptr_type ex_; |
|
|
|
// This declaration should be only included conditionally, but is included to maintain the same layout. |
|
virtual void launch_continuation() |
|
{ |
|
} |
|
|
|
shared_state_base(): |
|
done(false), |
|
is_valid_(true), |
|
is_deferred_(false), |
|
is_constructed(false), |
|
policy_(launch::none), |
|
continuations(), |
|
ex_() |
|
{} |
|
|
|
shared_state_base(exceptional_ptr const& ex): |
|
exception(ex.ptr_), |
|
done(true), |
|
is_valid_(true), |
|
is_deferred_(false), |
|
is_constructed(false), |
|
policy_(launch::none), |
|
continuations(), |
|
ex_() |
|
{} |
|
|
|
|
|
virtual ~shared_state_base() |
|
{ |
|
} |
|
|
|
bool is_done() |
|
{ |
|
return done; |
|
} |
|
|
|
executor_ptr_type get_executor() |
|
{ |
|
return ex_; |
|
} |
|
|
|
void set_executor_policy(executor_ptr_type aex) |
|
{ |
|
set_executor(); |
|
ex_ = aex; |
|
} |
|
void set_executor_policy(executor_ptr_type aex, boost::lock_guard<boost::mutex>&) |
|
{ |
|
set_executor(); |
|
ex_ = aex; |
|
} |
|
void set_executor_policy(executor_ptr_type aex, boost::unique_lock<boost::mutex>&) |
|
{ |
|
set_executor(); |
|
ex_ = aex; |
|
} |
|
|
|
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 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; |
|
} |
|
#else |
|
void set_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 0 |
|
// this inline definition results in ODR. See https://github.com/boostorg/thread/issues/193 |
|
// to avoid it, we define the function on the derived templates using the macro BOOST_THREAD_DO_CONTINUATION |
|
#define BOOST_THREAD_DO_CONTINUATION |
|
#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) { |
|
(*it)->launch_continuation(); |
|
} |
|
} |
|
} |
|
#else |
|
void do_continuation(boost::unique_lock<boost::mutex>&) |
|
{ |
|
} |
|
#endif |
|
|
|
#else |
|
#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION |
|
#define BOOST_THREAD_DO_CONTINUATION \ |
|
void do_continuation(boost::unique_lock<boost::mutex>& lock) \ |
|
{ \ |
|
if (! this->continuations.empty()) { \ |
|
continuations_type the_continuations = this->continuations; \ |
|
this->continuations.clear(); \ |
|
relocker rlk(lock); \ |
|
for (continuations_type::iterator it = the_continuations.begin(); it != the_continuations.end(); ++it) { \ |
|
(*it)->launch_continuation(); \ |
|
} \ |
|
} \ |
|
} |
|
#else |
|
#define BOOST_THREAD_DO_CONTINUATION \ |
|
void do_continuation(boost::unique_lock<boost::mutex>&) \ |
|
{ \ |
|
} |
|
#endif |
|
|
|
virtual void do_continuation(boost::unique_lock<boost::mutex>&) = 0; |
|
#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 notify_deferred() |
|
{ |
|
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); |
|
} |
|
waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this))); |
|
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 |
|
template<typename Duration> |
|
bool timed_wait(Duration const& rel_time) |
|
{ |
|
boost::unique_lock<boost::mutex> lock(this->mutex); |
|
if (is_deferred_) |
|
return false; |
|
|
|
do_callback(lock); |
|
return waiters.timed_wait(lock, rel_time, boost::bind(&shared_state_base::is_done, boost::ref(*this))); |
|
} |
|
|
|
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); |
|
return waiters.timed_wait(lock, target_time, boost::bind(&shared_state_base::is_done, boost::ref(*this))); |
|
} |
|
#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); |
|
if(!waiters.wait_until(lock, abs_time, boost::bind(&shared_state_base::is_done, boost::ref(*this)))) |
|
{ |
|
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_deferred(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; |
|
} |
|
void set_exception_at_thread_exit(exception_ptr e) |
|
{ |
|
set_exception_deferred(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>&) 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(exceptional_ptr const& ex): |
|
detail::shared_state_base(ex), result() |
|
{} |
|
|
|
// locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193 |
|
BOOST_THREAD_DO_CONTINUATION |
|
|
|
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_deferred(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; |
|
} |
|
void set_value_deferred(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; |
|
} |
|
|
|
void set_value_at_thread_exit(source_reference_type result_) |
|
{ |
|
set_value_deferred(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_) |
|
{ |
|
set_value_deferred(boost::move(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(exceptional_ptr const& ex): |
|
detail::shared_state_base(ex), result(0) |
|
{} |
|
|
|
// locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193 |
|
BOOST_THREAD_DO_CONTINUATION |
|
|
|
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_deferred(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; |
|
} |
|
|
|
void set_value_at_thread_exit(T& result_) |
|
{ |
|
set_value_deferred(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() |
|
{} |
|
|
|
shared_state(exceptional_ptr const& ex): |
|
detail::shared_state_base(ex) |
|
{} |
|
|
|
// locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193 |
|
BOOST_THREAD_DO_CONTINUATION |
|
|
|
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_deferred() |
|
{ |
|
unique_lock<boost::mutex> lk(this->mutex); |
|
if (this->has_value(lk)) |
|
{ |
|
throw_exception(promise_already_satisfied()); |
|
} |
|
this->is_constructed = true; |
|
} |
|
void set_value_at_thread_exit() |
|
{ |
|
set_value_deferred(); |
|
// 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: |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
boost::thread thr_; |
|
void join() |
|
{ |
|
if (this_thread::get_id() == thr_.get_id()) |
|
{ |
|
thr_.detach(); |
|
return; |
|
} |
|
if (thr_.joinable()) thr_.join(); |
|
} |
|
#endif |
|
public: |
|
future_async_shared_state_base() |
|
{ |
|
this->set_async(); |
|
} |
|
|
|
~future_async_shared_state_base() |
|
{ |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
join(); |
|
#elif defined BOOST_THREAD_ASYNC_FUTURE_WAITS |
|
unique_lock<boost::mutex> lk(this->mutex); |
|
this->waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this))); |
|
#endif |
|
} |
|
|
|
virtual void wait(boost::unique_lock<boost::mutex>& lk, bool rethrow) |
|
{ |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
{ |
|
relocker rlk(lk); |
|
join(); |
|
} |
|
#endif |
|
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) |
|
{ |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_async_shared_state::run, static_shared_from_this(this), boost::forward<Fp>(f)); |
|
#else |
|
boost::thread(&future_async_shared_state::run, static_shared_from_this(this), boost::forward<Fp>(f)).detach(); |
|
#endif |
|
} |
|
|
|
static void run(shared_ptr<future_async_shared_state> that, BOOST_THREAD_FWD_REF(Fp) f) |
|
{ |
|
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) |
|
{ |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_async_shared_state::run, static_shared_from_this(this), boost::move(f)); |
|
#else |
|
boost::thread(&future_async_shared_state::run, static_shared_from_this(this), boost::move(f)).detach(); |
|
#endif |
|
} |
|
|
|
static void run(shared_ptr<future_async_shared_state> that, BOOST_THREAD_FWD_REF(Fp) f) |
|
{ |
|
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) |
|
{ |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_async_shared_state::run, static_shared_from_this(this), boost::move(f)); |
|
#else |
|
boost::thread(&future_async_shared_state::run, static_shared_from_this(this), boost::move(f)).detach(); |
|
#endif |
|
} |
|
|
|
static void run(shared_ptr<future_async_shared_state> that, BOOST_THREAD_FWD_REF(Fp) f) |
|
{ |
|
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> |
|
{ |
|
Fp func_; |
|
|
|
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&> |
|
{ |
|
Fp func_; |
|
|
|
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> |
|
{ |
|
Fp func_; |
|
|
|
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 |
|
{ |
|
public: |
|
typedef std::vector<int>::size_type count_type; |
|
private: |
|
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>,typename detail::future_waiter::count_type>::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> |
|
typename detail::future_waiter::count_type 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> |
|
typename detail::future_waiter::count_type 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> |
|
typename detail::future_waiter::count_type 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>, typename detail::future_waiter::count_type>::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) { |
|
return future_ptr(new detail::shared_state<R>(ex)); |
|
} |
|
|
|
future_ptr future_; |
|
|
|
basic_future(future_ptr a_future): |
|
future_(a_future) |
|
{ |
|
} |
|
|
|
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)) |
|
{ |
|
} |
|
|
|
~basic_future() { |
|
} |
|
|
|
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 |
|
{ |
|
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); |
|
} |
|
|
|
launch launch_policy() const |
|
{ |
|
if ( future_ ) { |
|
boost::unique_lock<boost::mutex> lk(this->future_->mutex); |
|
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_.get() != 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 |
|
{ |
|
if(!future_) |
|
{ |
|
boost::throw_exception(future_uninitialized()); |
|
} |
|
return future_->timed_wait(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_sync_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); |
|
|
|
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); |
|
|
|
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); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
BOOST_THREAD_FUTURE<Rp> |
|
make_shared_future_sync_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
|
|
#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); |
|
|
|
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); |
|
|
|
template <class Rp, class Fp, class Executor> |
|
BOOST_THREAD_FUTURE<Rp> |
|
make_future_executor_shared_state(Executor& ex, BOOST_THREAD_FWD_REF(Fp) f); |
|
#endif |
|
#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 |
|
} |
|
#if defined(BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY) |
|
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); |
|
|
|
inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_all(); |
|
|
|
#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); |
|
#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); |
|
|
|
inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_any(); |
|
|
|
#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); |
|
#endif |
|
#endif // BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY |
|
|
|
|
|
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_sync_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); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_deferred_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_async_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_sync_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
template<typename Ex, typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::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); |
|
|
|
template<typename Ex, typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_executor_continuation_shared_state(Ex& ex, boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
template <class Rp, class Fp, class Executor> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_future_executor_shared_state(Executor& ex, BOOST_THREAD_FWD_REF(Fp) f); |
|
#endif |
|
#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_FUTURE_WHEN_ALL_WHEN_ANY) |
|
template< typename InputIterator> |
|
friend typename boost::disable_if<is_future_type<InputIterator>, |
|
BOOST_THREAD_FUTURE<csbl::vector<typename InputIterator::value_type> > |
|
>::type |
|
when_all(InputIterator first, InputIterator last); |
|
|
|
//friend inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_all(); |
|
|
|
#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
|
template< typename T0, typename ...T> |
|
friend 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); |
|
#endif |
|
|
|
template< typename InputIterator> |
|
friend typename boost::disable_if<is_future_type<InputIterator>, |
|
BOOST_THREAD_FUTURE<csbl::vector<typename InputIterator::value_type> > |
|
>::type |
|
when_any(InputIterator first, InputIterator last); |
|
|
|
//friend inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_any(); |
|
|
|
#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
|
template< typename T0, typename ...T> |
|
friend 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); |
|
#endif |
|
#endif // BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY |
|
#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)))) |
|
{ |
|
} |
|
#if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP |
|
inline explicit BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R> >) other); // EXTENSION |
|
#endif |
|
|
|
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_.get() == 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_.get() == 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_.get() == 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_sync_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); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_deferred_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_async_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_sync_continuation_shared_state(boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
template<typename Ex, typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::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); |
|
|
|
template<typename Ex, typename F, typename Rp, typename Fp> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_shared_future_executor_continuation_shared_state(Ex& ex, boost::unique_lock<boost::mutex> &lock, F f, BOOST_THREAD_FWD_REF(Fp) c); |
|
|
|
template <class Rp, class Fp, class Executor> |
|
friend BOOST_THREAD_FUTURE<Rp> |
|
detail::make_future_executor_shared_state(Executor& ex, BOOST_THREAD_FWD_REF(Fp) f); |
|
#endif |
|
|
|
#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_FUTURE_WHEN_ALL_WHEN_ANY) |
|
template< typename InputIterator> |
|
friend typename boost::disable_if<is_future_type<InputIterator>, |
|
BOOST_THREAD_FUTURE<csbl::vector<typename InputIterator::value_type> > |
|
>::type |
|
when_all(InputIterator first, InputIterator last); |
|
|
|
friend inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_all(); |
|
|
|
#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
|
template< typename T0, typename ...T> |
|
friend 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); |
|
#endif |
|
|
|
template< typename InputIterator> |
|
friend typename boost::disable_if<is_future_type<InputIterator>, |
|
BOOST_THREAD_FUTURE<csbl::vector<typename InputIterator::value_type> > |
|
>::type |
|
when_any(InputIterator first, InputIterator last); |
|
|
|
friend inline BOOST_THREAD_FUTURE<csbl::tuple<> > when_any(); |
|
|
|
#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) |
|
template< typename T0, typename ...T> |
|
friend 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); |
|
#endif |
|
#endif // BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY |
|
|
|
#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_.get() == 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_.get() == 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_.get() == 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_sync_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) |
|
{ |
|
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/thread/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/thread/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); |
|
} |
|
|
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
void set_executor(executor_ptr_type aex) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
boost::lock_guard<boost::mutex> lk(future_->mutex); |
|
future_->set_executor_policy(aex, lk); |
|
} |
|
#endif |
|
// 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_RVALUE_REFERENCES |
|
template <class TR> |
|
typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type |
|
set_value_deferred(TR const & r) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->set_value_deferred(r); |
|
} |
|
#else |
|
void set_value_deferred(source_reference_type r) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->set_value_deferred(r); |
|
} |
|
#endif |
|
|
|
void set_value_deferred(rvalue_source_type r) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES |
|
future_->set_value_deferred(boost::move(r)); |
|
#else |
|
future_->set_value_deferred(static_cast<rvalue_source_type>(r)); |
|
#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)); |
|
} |
|
void set_exception_deferred(boost::exception_ptr p) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->set_exception_deferred(p); |
|
} |
|
template <typename E> |
|
void set_exception_deferred(E ex) |
|
{ |
|
set_exception_deferred(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); |
|
} |
|
void notify_deferred() |
|
{ |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->notify_deferred(); |
|
} |
|
|
|
}; |
|
|
|
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/thread/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/thread/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_value_deferred(R& r) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_already_satisfied()); |
|
} |
|
future_->set_value_deferred(r); |
|
} |
|
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)); |
|
} |
|
void set_exception_deferred(boost::exception_ptr p) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->set_exception_deferred(p); |
|
} |
|
template <typename E> |
|
void set_exception_deferred(E ex) |
|
{ |
|
set_exception_deferred(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); |
|
} |
|
void notify_deferred() |
|
{ |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->notify_deferred(); |
|
} |
|
}; |
|
|
|
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_value_deferred() |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->set_value_deferred(); |
|
} |
|
|
|
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)); |
|
} |
|
void set_exception_deferred(boost::exception_ptr p) |
|
{ |
|
lazy_init(); |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->set_exception_deferred(p); |
|
} |
|
template <typename E> |
|
void set_exception_deferred(E ex) |
|
{ |
|
set_exception_deferred(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); |
|
} |
|
void notify_deferred() |
|
{ |
|
if (future_.get()==0) |
|
{ |
|
boost::throw_exception(promise_moved()); |
|
} |
|
future_->notify_deferred(); |
|
} |
|
}; |
|
} |
|
#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_FUNCTION_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)(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)(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_FUNCTION_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_FUNCTION_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_FUNCTION_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; |
|
} |
|
|
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
void set_executor(executor_ptr_type aex) |
|
{ |
|
if (!valid()) |
|
boost::throw_exception(task_moved()); |
|
boost::lock_guard<boost::mutex> lk(task->mutex); |
|
task->set_executor_policy(aex, lk); |
|
} |
|
#endif |
|
void reset() { |
|
if (!valid()) |
|
boost::throw_exception(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()(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_FUNCTION_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_FUNCTION_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 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 |
|
{ |
|
|
|
typedef shared_ptr<shared_state_base > storage_type; |
|
storage_type that; |
|
Fp f_; |
|
public: |
|
|
|
shared_state_nullary_task(storage_type 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.reset(); |
|
} |
|
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.reset(); |
|
} |
|
return *this; |
|
} |
|
#endif |
|
void operator()() { |
|
shared_ptr<shared_state<Rp> > that_ = static_pointer_cast<shared_state<Rp> >(that); |
|
try { |
|
that_->mark_finished_with_result(f_()); |
|
} catch(...) { |
|
that_->mark_exceptional_finish(); |
|
} |
|
} |
|
~shared_state_nullary_task() |
|
{ |
|
} |
|
}; |
|
|
|
template<typename Fp> |
|
struct shared_state_nullary_task<void, Fp> |
|
{ |
|
typedef shared_ptr<shared_state_base > storage_type; |
|
storage_type that; |
|
Fp f_; |
|
public: |
|
shared_state_nullary_task(storage_type 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.reset(); |
|
} |
|
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.reset(); |
|
} |
|
return *this; |
|
} |
|
#endif |
|
void operator()() { |
|
shared_ptr<shared_state<void> > that_ = static_pointer_cast<shared_state<void> >(that); |
|
try { |
|
f_(); |
|
that_->mark_finished_with_result(); |
|
} catch(...) { |
|
that_->mark_exceptional_finish(); |
|
} |
|
} |
|
}; |
|
|
|
} |
|
BOOST_THREAD_DCL_MOVABLE_BEG2(R,F) detail::shared_state_nullary_task<R,F> BOOST_THREAD_DCL_MOVABLE_END |
|
namespace detail { |
|
|
|
///////////////////////// |
|
/// future_executor_shared_state_base |
|
///////////////////////// |
|
template<typename Rp> |
|
struct future_executor_shared_state: shared_state<Rp> |
|
{ |
|
typedef shared_state<Rp> base_type; |
|
protected: |
|
public: |
|
future_executor_shared_state() { |
|
} |
|
|
|
template <class Fp, class Executor> |
|
void init(Executor& ex, BOOST_THREAD_FWD_REF(Fp) f) |
|
{ |
|
typedef typename decay<Fp>::type Cont; |
|
this->set_executor_policy(executor_ptr_type(new executor_ref<Executor>(ex))); |
|
shared_state_nullary_task<Rp,Cont> t(this->shared_from_this(), boost::forward<Fp>(f)); |
|
ex.submit(boost::move(t)); |
|
} |
|
|
|
~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> > |
|
h(new future_executor_shared_state<Rp>()); |
|
h->init(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_FUNCTION_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_FUNCTION_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_FUNCTION_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_FUNCTION_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_FUNCTION_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_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_ready_future(exception_ptr ex) { |
|
return make_exceptional_future<T>(ex); |
|
} |
|
|
|
#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 |
|
{ |
|
////////////////////// |
|
// detail::continuation_shared_state |
|
////////////////////// |
|
template<typename F, typename Rp, typename Fp, class ShSt=shared_state<Rp> > |
|
struct continuation_shared_state: ShSt |
|
{ |
|
F parent; |
|
Fp continuation; |
|
|
|
public: |
|
continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: parent(boost::move(f)), |
|
continuation(boost::move(c)) |
|
{ |
|
} |
|
|
|
void init(boost::unique_lock<boost::mutex> &lock) |
|
{ |
|
parent.future_->set_continuation_ptr(this->shared_from_this(), lock); |
|
} |
|
|
|
void call() { |
|
try { |
|
this->mark_finished_with_result(this->continuation(boost::move(this->parent))); |
|
} catch(...) { |
|
this->mark_exceptional_finish(); |
|
} |
|
// make sure parent is really cleared to prevent memory "leaks" |
|
this->parent = F(); |
|
} |
|
|
|
void call(boost::unique_lock<boost::mutex>& lck) { |
|
try { |
|
relocker relock(lck); |
|
|
|
// neither continuation nor parent are protected by the lock - call() must only |
|
// be called once, and no one else must modify it. |
|
Rp res = this->continuation(boost::move(this->parent)); |
|
|
|
// make sure parent is really cleared to prevent memory "leaks" |
|
this->parent = F(); |
|
|
|
relock.lock(); |
|
|
|
this->mark_finished_with_result_internal(boost::move(res), lck); |
|
} catch (...) { |
|
this->mark_exceptional_finish_internal(current_exception(), lck); |
|
|
|
// make sure parent is really cleared to prevent memory "leaks" |
|
relocker relock(lck); |
|
this->parent = F(); |
|
} |
|
} |
|
|
|
static void run(shared_ptr<boost::detail::shared_state_base> that_) |
|
{ |
|
continuation_shared_state* that = static_cast<continuation_shared_state*>(that_.get()); |
|
that->call(); |
|
} |
|
|
|
~continuation_shared_state() {} |
|
}; |
|
|
|
template<typename F, typename Fp, class ShSt> |
|
struct continuation_shared_state<F, void, Fp, ShSt>: ShSt |
|
{ |
|
F parent; |
|
Fp continuation; |
|
|
|
public: |
|
continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: parent(boost::move(f)), |
|
continuation(boost::move(c)) |
|
{ |
|
} |
|
|
|
void init(boost::unique_lock<boost::mutex> &lock) |
|
{ |
|
parent.future_->set_continuation_ptr(this->shared_from_this(), lock); |
|
} |
|
|
|
void call() |
|
{ |
|
try { |
|
this->continuation(boost::move(this->parent)); |
|
this->mark_finished_with_result(); |
|
} catch(...) { |
|
this->mark_exceptional_finish(); |
|
} |
|
// make sure parent is really cleared to prevent memory "leaks" |
|
this->parent = F(); |
|
} |
|
|
|
void call(boost::unique_lock<boost::mutex>& lck) { |
|
try { |
|
{ |
|
relocker relock(lck); |
|
// neither continuation nor parent are protected by the lock - call() must only |
|
// be called once, and no one else must modify it. |
|
this->continuation(boost::move(this->parent)); |
|
|
|
// make sure parent is really cleared to prevent memory "leaks" |
|
this->parent = F(); |
|
} |
|
this->mark_finished_with_result_internal(lck); |
|
} catch (...) { |
|
this->mark_exceptional_finish_internal(current_exception(), lck); |
|
|
|
// make sure parent is really cleared to prevent memory "leaks" |
|
relocker relock(lck); |
|
this->parent = F(); |
|
} |
|
} |
|
|
|
static void run(shared_ptr<boost::detail::shared_state_base> that_) |
|
{ |
|
continuation_shared_state* that = static_cast<continuation_shared_state*>(that_.get()); |
|
that->call(); |
|
} |
|
|
|
~continuation_shared_state() {} |
|
}; |
|
///////////////////////// |
|
/// future_async_continuation_shared_state |
|
///////////////////////// |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
struct future_async_continuation_shared_state: continuation_shared_state<F,Rp,Fp,future_async_shared_state_base<Rp> > |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp,future_async_shared_state_base<Rp> > base_type; |
|
public: |
|
future_async_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ } |
|
|
|
void launch_continuation() { |
|
#if defined BOOST_THREAD_FUTURE_BLOCKING |
|
boost::lock_guard<boost::mutex> lk(this->mutex); |
|
this->thr_ = boost::thread(&future_async_continuation_shared_state::run, static_shared_from_this(this)); |
|
#else |
|
boost::thread(&base_type::run, static_shared_from_this(this)).detach(); |
|
#endif |
|
} |
|
}; |
|
|
|
///////////////////////// |
|
/// future_sync_continuation_shared_state |
|
///////////////////////// |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
struct future_sync_continuation_shared_state: continuation_shared_state<F,Rp,Fp,shared_state<Rp> > |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp,shared_state<Rp> > base_type; |
|
public: |
|
future_sync_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ } |
|
|
|
void launch_continuation() { |
|
this->call(); |
|
} |
|
}; |
|
|
|
|
|
///////////////////////// |
|
/// future_executor_continuation_shared_state |
|
///////////////////////// |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
|
|
template <typename FutureExecutorContinuationSharedState> |
|
struct run_it { |
|
shared_ptr<FutureExecutorContinuationSharedState> that_; |
|
|
|
#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) |
|
BOOST_THREAD_COPYABLE_AND_MOVABLE(run_it) |
|
run_it(run_it const& x) //BOOST_NOEXCEPT |
|
: that_(x.that_) |
|
{} |
|
run_it& operator=(BOOST_THREAD_COPY_ASSIGN_REF(run_it) x) //BOOST_NOEXCEPT |
|
{ |
|
if (this != &x) { |
|
that_=x.that_; |
|
} |
|
return *this; |
|
} |
|
// move |
|
run_it(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT |
|
: that_(x.that_) |
|
{ |
|
x.that_.reset(); |
|
} |
|
run_it& operator=(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT { |
|
if (this != &x) { |
|
that_=x.that; |
|
x.that_.reset(); |
|
} |
|
return *this; |
|
} |
|
#endif |
|
run_it(shared_ptr<FutureExecutorContinuationSharedState> that) : that_ (that) {} |
|
|
|
void operator()() |
|
{ |
|
that_->run(that_); |
|
} |
|
}; |
|
|
|
} |
|
BOOST_THREAD_DCL_MOVABLE_BEG(F) detail::run_it<F> BOOST_THREAD_DCL_MOVABLE_END |
|
|
|
namespace detail { |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
struct future_executor_continuation_shared_state: continuation_shared_state<F,Rp,Fp> |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp> base_type; |
|
|
|
public: |
|
future_executor_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ |
|
} |
|
|
|
template <class Ex> |
|
void init(boost::unique_lock<boost::mutex> &lk, Ex& ex) |
|
{ |
|
this->set_executor_policy(executor_ptr_type(new executor_ref<Ex>(ex)), lk); |
|
this->base_type::init(lk); |
|
} |
|
|
|
void launch_continuation() { |
|
run_it<base_type> fct(static_shared_from_this(this)); |
|
this->get_executor()->submit(boost::move(fct)); |
|
} |
|
|
|
~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: continuation_shared_state<F,Rp,Fp,future_async_shared_state_base<Rp> > |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp,future_async_shared_state_base<Rp> > base_type; |
|
|
|
public: |
|
shared_future_async_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ |
|
} |
|
|
|
void launch_continuation() { |
|
#if defined BOOST_THREAD_FUTURE_BLOCKING |
|
boost::lock_guard<boost::mutex> lk(this->mutex); |
|
this->thr_ = boost::thread(&base_type::run, static_shared_from_this(this)); |
|
#else |
|
boost::thread(&base_type::run, static_shared_from_this(this)).detach(); |
|
#endif |
|
} |
|
}; |
|
|
|
///////////////////////// |
|
/// shared_future_async_continuation_shared_state |
|
///////////////////////// |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
struct shared_future_sync_continuation_shared_state: continuation_shared_state<F,Rp,Fp,shared_state<Rp> > |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp,shared_state<Rp> > base_type; |
|
|
|
public: |
|
shared_future_sync_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ |
|
} |
|
|
|
void launch_continuation() { |
|
this->call(); |
|
} |
|
}; |
|
|
|
|
|
///////////////////////// |
|
/// shared_future_executor_continuation_shared_state |
|
///////////////////////// |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
|
|
template<typename F, typename Rp, typename Fp> |
|
struct shared_future_executor_continuation_shared_state: continuation_shared_state<F,Rp,Fp> |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp> base_type; |
|
|
|
public: |
|
|
|
shared_future_executor_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ |
|
} |
|
|
|
template <class Ex> |
|
void init(boost::unique_lock<boost::mutex> &lk, Ex& ex) |
|
{ |
|
this->set_executor_policy(executor_ptr_type(new executor_ref<Ex>(ex)), lk); |
|
this->base_type::init(lk); |
|
} |
|
|
|
void launch_continuation() { |
|
run_it<base_type> fct(static_shared_from_this(this)); |
|
this->get_executor()->submit(boost::move(fct)); |
|
} |
|
|
|
~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: continuation_shared_state<F,Rp,Fp> |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp> base_type; |
|
public: |
|
future_deferred_continuation_shared_state(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ |
|
this->set_deferred(); |
|
} |
|
|
|
virtual void execute(boost::unique_lock<boost::mutex>& lk) { |
|
this->parent.wait(); |
|
this->call(lk); |
|
} |
|
|
|
virtual void launch_continuation() { } |
|
}; |
|
|
|
////////////////////////// |
|
/// shared_future_deferred_continuation_shared_state |
|
////////////////////////// |
|
template<typename F, typename Rp, typename Fp> |
|
struct shared_future_deferred_continuation_shared_state: continuation_shared_state<F,Rp,Fp> |
|
{ |
|
typedef continuation_shared_state<F,Rp,Fp> base_type; |
|
|
|
public: |
|
shared_future_deferred_continuation_shared_state(F f, BOOST_THREAD_FWD_REF(Fp) c) |
|
: base_type(boost::move(f), boost::forward<Fp>(c)) |
|
{ |
|
this->set_deferred(); |
|
} |
|
|
|
virtual void execute(boost::unique_lock<boost::mutex>& lk) { |
|
this->parent.wait(); |
|
this->call(lk); |
|
} |
|
|
|
virtual void launch_continuation() { } |
|
}; |
|
|
|
//////////////////////////////// |
|
// 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) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<future_deferred_continuation_shared_state<F, Rp, Cont> > |
|
h(new future_deferred_continuation_shared_state<F, Rp, Cont>(boost::move(f), boost::forward<Fp>(c))); |
|
h->init(lock); |
|
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) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<future_async_continuation_shared_state<F,Rp, Cont> > |
|
h(new future_async_continuation_shared_state<F,Rp, Cont>(boost::move(f), boost::forward<Fp>(c))); |
|
h->init(lock); |
|
|
|
return BOOST_THREAD_FUTURE<Rp>(h); |
|
} |
|
//////////////////////////////// |
|
// make_future_sync_continuation_shared_state |
|
//////////////////////////////// |
|
template<typename F, typename Rp, typename Fp> |
|
BOOST_THREAD_FUTURE<Rp> |
|
make_future_sync_continuation_shared_state( |
|
boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f, |
|
BOOST_THREAD_FWD_REF(Fp) c) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<future_sync_continuation_shared_state<F,Rp, Cont> > |
|
h(new future_sync_continuation_shared_state<F,Rp, Cont>(boost::move(f), boost::forward<Fp>(c))); |
|
h->init(lock); |
|
|
|
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) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<future_executor_continuation_shared_state<F,Rp, Cont> > |
|
h(new future_executor_continuation_shared_state<F,Rp, Cont>(boost::move(f), boost::forward<Fp>(c))); |
|
h->init(lock, ex); |
|
|
|
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) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<shared_future_deferred_continuation_shared_state<F, Rp, Cont> > |
|
h(new shared_future_deferred_continuation_shared_state<F, Rp, Cont>(f, boost::forward<Fp>(c))); |
|
h->init(lock); |
|
|
|
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) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<shared_future_async_continuation_shared_state<F,Rp, Cont> > |
|
h(new shared_future_async_continuation_shared_state<F,Rp, Cont>(f, boost::forward<Fp>(c))); |
|
h->init(lock); |
|
|
|
return BOOST_THREAD_FUTURE<Rp>(h); |
|
} |
|
//////////////////////////////// |
|
// make_shared_future_sync_continuation_shared_state |
|
//////////////////////////////// |
|
template<typename F, typename Rp, typename Fp> |
|
BOOST_THREAD_FUTURE<Rp> |
|
make_shared_future_sync_continuation_shared_state( |
|
boost::unique_lock<boost::mutex> &lock, F f, |
|
BOOST_THREAD_FWD_REF(Fp) c) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<shared_future_sync_continuation_shared_state<F,Rp, Cont> > |
|
h(new shared_future_sync_continuation_shared_state<F,Rp, Cont>(f, boost::forward<Fp>(c))); |
|
h->init(lock); |
|
|
|
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) { |
|
typedef typename decay<Fp>::type Cont; |
|
shared_ptr<shared_future_executor_continuation_shared_state<F, Rp, Cont> > |
|
h(new shared_future_executor_continuation_shared_state<F, Rp, Cont>(f, boost::forward<Fp>(c))); |
|
h->init(lock, ex); |
|
|
|
return BOOST_THREAD_FUTURE<Rp>(h); |
|
} |
|
#endif |
|
} |
|
|
|
//////////////////////////////// |
|
// template<typename F> |
|
// auto future<R>::then(launch policy, 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_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->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>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy) & int(launch::sync)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
} else if (underlying_cast<int>(policy) & int(launch::executor)) { |
|
assert(this->future_->get_executor()); |
|
typedef executor Ex; |
|
Ex& ex = *(this->future_->get_executor()); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type>(ex, |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#endif |
|
} else if (underlying_cast<int>(policy) & int(launch::inherit)) { |
|
|
|
launch policy_ = this->launch_policy(lock); |
|
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>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy_) & int(launch::sync)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
} else if (underlying_cast<int>(policy_) & int(launch::executor)) { |
|
assert(this->future_->get_executor()); |
|
typedef executor Ex; |
|
Ex& ex = *(this->future_->get_executor()); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type>(ex, |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#endif |
|
} else { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} |
|
} |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
//////////////////////////////// |
|
// template<typename Ex, typename F> |
|
// auto future<future<R2> >::then(Ex&, F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>; |
|
//////////////////////////////// |
|
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_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->mutex); |
|
|
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type>(ex, |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} |
|
#endif |
|
//////////////////////////////// |
|
// template<typename F> |
|
// auto future<future<R2> >::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(BOOST_THREAD_FWD_REF(F) func) { |
|
|
|
#ifndef BOOST_THREAD_CONTINUATION_SYNC |
|
return this->then(this->launch_policy(), boost::forward<F>(func)); |
|
#else |
|
typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type; |
|
BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->mutex); |
|
|
|
launch policy = this->launch_policy(lock); |
|
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>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} |
|
#endif |
|
|
|
} |
|
|
|
//////////////////////////////// |
|
// template<typename F> |
|
// auto future<future<R2> >::then(launch, 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_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->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>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy) & int(launch::sync)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
} else if (underlying_cast<int>(policy) & int(launch::executor)) { |
|
assert(this->future_->get_executor()); |
|
typedef executor Ex; |
|
Ex& ex = *(this->future_->get_executor()); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type>(ex, |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#endif |
|
} else if (underlying_cast<int>(policy) & int(launch::inherit)) { |
|
launch policy_ = this->launch_policy(lock); |
|
|
|
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>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy_) & int(launch::sync)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
} else if (underlying_cast<int>(policy_) & int(launch::executor)) { |
|
assert(this->future_->get_executor()); |
|
typedef executor Ex; |
|
Ex& ex = *(this->future_->get_executor()); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type>(ex, |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
#endif |
|
} else { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_async_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} |
|
} |
|
|
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
//////////////////////////////// |
|
// template<typename Ex, typename F> |
|
// auto future<future<R2> >::then(Ex&, F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>; |
|
//////////////////////////////// |
|
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_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->mutex); |
|
|
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_executor_continuation_shared_state<Ex, BOOST_THREAD_FUTURE<R>, future_type>(ex, |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} |
|
#endif |
|
|
|
//////////////////////////////// |
|
// 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(BOOST_THREAD_FWD_REF(F) func) { |
|
|
|
#ifndef BOOST_THREAD_CONTINUATION_SYNC |
|
return this->then(this->launch_policy(), boost::forward<F>(func)); |
|
#else |
|
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_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->mutex); |
|
|
|
launch policy = this->launch_policy(lock); |
|
|
|
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>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} else { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_future_sync_continuation_shared_state<BOOST_THREAD_FUTURE<R>, future_type>( |
|
lock, boost::move(*this), boost::forward<F>(func) |
|
))); |
|
} |
|
#endif |
|
} |
|
|
|
//////////////////////////////// |
|
// template<typename F> |
|
// auto shared_future<R>::then(launch policy, 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_.get()!=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_shared_future_async_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy) & int(launch::deferred)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_deferred_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy) & int(launch::sync)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_sync_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
} else if (underlying_cast<int>(policy) & int(launch::executor)) { |
|
typedef executor Ex; |
|
Ex& ex = *(this->future_->get_executor()); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_executor_continuation_shared_state<Ex, shared_future<R>, future_type>(ex, |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
#endif |
|
} else if (underlying_cast<int>(policy) & int(launch::inherit)) { |
|
|
|
launch policy_ = this->launch_policy(lock); |
|
if (underlying_cast<int>(policy_) & int(launch::async)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy_) & int(launch::deferred)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_deferred_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} else if (underlying_cast<int>(policy_) & int(launch::sync)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_sync_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
} else if (underlying_cast<int>(policy_) & int(launch::executor)) { |
|
typedef executor Ex; |
|
Ex& ex = *(this->future_->get_executor()); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_executor_continuation_shared_state<Ex, shared_future<R>, future_type>(ex, |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
#endif |
|
} else { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} |
|
|
|
} else { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_async_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} |
|
} |
|
#ifdef BOOST_THREAD_PROVIDES_EXECUTORS |
|
//////////////////////////////// |
|
// template<typename Ex, typename F> |
|
// auto shared_future<R>::then(Ex&, F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>; |
|
//////////////////////////////// |
|
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_.get()!=0, future_uninitialized()); |
|
|
|
boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_executor_continuation_shared_state<Ex, shared_future<R>, future_type>(ex, |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} |
|
#endif |
|
|
|
//////////////////////////////// |
|
// 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(BOOST_THREAD_FWD_REF(F) func) const { |
|
#ifndef BOOST_THREAD_CONTINUATION_SYNC |
|
return this->then(this->launch_policy(), boost::forward<F>(func)); |
|
#else |
|
typedef typename boost::result_of<F(shared_future<R>)>::type future_type; |
|
BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized()); |
|
|
|
boost::unique_lock<boost::mutex> lock(this->future_->mutex); |
|
launch policy = this->launch_policy(lock); |
|
if (underlying_cast<int>(policy) & int(launch::deferred)) { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_deferred_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} else { |
|
return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_sync_continuation_shared_state<shared_future<R>, future_type>( |
|
lock, *this, boost::forward<F>(func) |
|
))); |
|
} |
|
#endif |
|
} |
|
|
|
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 wrapped; |
|
typename F::value_type unwrapped; |
|
public: |
|
explicit future_unwrap_shared_state(BOOST_THREAD_RV_REF(F) f) |
|
: wrapped(boost::move(f)) { |
|
} |
|
|
|
void launch_continuation() |
|
{ |
|
boost::unique_lock<boost::mutex> lk(this->mutex); |
|
// assert(wrapped.is_ready()); |
|
if (! unwrapped.valid() ) |
|
{ |
|
if (wrapped.has_exception()) { |
|
this->mark_exceptional_finish_internal(wrapped.get_exception_ptr(), lk); |
|
} else { |
|
unwrapped = wrapped.get(); |
|
if (unwrapped.valid()) |
|
{ |
|
lk.unlock(); |
|
boost::unique_lock<boost::mutex> lk2(unwrapped.future_->mutex); |
|
unwrapped.future_->set_continuation_ptr(this->shared_from_this(), lk2); |
|
} else { |
|
this->mark_exceptional_finish_internal(boost::copy_exception(future_uninitialized()), lk); |
|
} |
|
} |
|
} else { |
|
// assert(unwrapped.is_ready()); |
|
if (unwrapped.has_exception()) { |
|
this->mark_exceptional_finish_internal(unwrapped.get_exception_ptr(), lk); |
|
} else { |
|
this->mark_finished_with_result_internal(unwrapped.get(), lk); |
|
} |
|
} |
|
} |
|
}; |
|
|
|
template<typename F> |
|
struct future_unwrap_shared_state<F,void>: shared_state<void> |
|
{ |
|
F wrapped; |
|
typename F::value_type unwrapped; |
|
public: |
|
explicit future_unwrap_shared_state(BOOST_THREAD_RV_REF(F) f) |
|
: wrapped(boost::move(f)) { |
|
} |
|
|
|
void launch_continuation() |
|
{ |
|
boost::unique_lock<boost::mutex> lk(this->mutex); |
|
// assert(wrapped.is_ready()); |
|
if (! unwrapped.valid() ) |
|
{ |
|
if (wrapped.has_exception()) { |
|
this->mark_exceptional_finish_internal(wrapped.get_exception_ptr(), lk); |
|
} else { |
|
unwrapped = wrapped.get(); |
|
if (unwrapped.valid()) |
|
{ |
|
lk.unlock(); |
|
boost::unique_lock<boost::mutex> lk2(unwrapped.future_->mutex); |
|
unwrapped.future_->set_continuation_ptr(this->shared_from_this(), lk2); |
|
} else { |
|
this->mark_exceptional_finish_internal(boost::copy_exception(future_uninitialized()), lk); |
|
} |
|
} |
|
} else { |
|
// assert(unwrapped.is_ready()); |
|
if (unwrapped.has_exception()) { |
|
this->mark_exceptional_finish_internal(unwrapped.get_exception_ptr(), lk); |
|
} else { |
|
this->mark_finished_with_result_internal(lk); |
|
} |
|
} |
|
} |
|
}; |
|
|
|
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))); |
|
h->wrapped.future_->set_continuation_ptr(h, lock); |
|
|
|
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_.get()!=0, future_uninitialized()); |
|
|
|
// keep state alive as we move ourself but hold the lock |
|
shared_ptr<detail::shared_state_base> sentinel(this->future_); |
|
boost::unique_lock<boost::mutex> lock(sentinel->mutex); |
|
|
|
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 = static_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; |
|
} |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_when_all_vector_shared_state::run, this->shared_from_this()); |
|
#else |
|
boost::thread(&future_when_all_vector_shared_state::run, this->shared_from_this()).detach(); |
|
#endif |
|
} |
|
|
|
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 = static_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; |
|
} |
|
|
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_when_any_vector_shared_state::run, this->shared_from_this()); |
|
#else |
|
boost::thread(&future_when_any_vector_shared_state::run, this->shared_from_this()).detach(); |
|
#endif |
|
} |
|
|
|
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 = static_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; |
|
} |
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_when_all_tuple_shared_state::run, this->shared_from_this()); |
|
#else |
|
boost::thread(&future_when_all_tuple_shared_state::run, this->shared_from_this()).detach(); |
|
#endif |
|
|
|
} |
|
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 = static_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; |
|
} |
|
|
|
#ifdef BOOST_THREAD_FUTURE_BLOCKING |
|
this->thr_ = boost::thread(&future_when_any_tuple_shared_state::run, this->shared_from_this()); |
|
#else |
|
boost::thread(&future_when_any_tuple_shared_state::run, this->shared_from_this()).detach(); |
|
#endif |
|
} |
|
|
|
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_EXCEPTIONS |
|
#endif // header
|
|
|