Standard library header  (C++11) (original) (raw)

This header is part of the thread support library.

[edit] Synopsis

namespace std { enum class future_errc { broken_promise = /* implementation-defined /, future_already_retrieved = / implementation-defined /, promise_already_satisfied = / implementation-defined /, no_state = / implementation-defined / };   enum class launch : / unspecified / { async = / unspecified /, deferred = / unspecified /, / implementation-defined */ };   enum class future_status { ready, timeout, deferred };   template<> struct is_error_code_enum : public true_type { }; error_code make_error_code(future_errc e) noexcept; error_condition make_error_condition(future_errc e) noexcept;   const error_category& future_category() noexcept;   class future_error;   template class promise; template class promise<R&>; template<> class promise;   template void swap(promise& x, promise& y) noexcept;   template<class R, class Alloc> struct uses_allocator<promise, Alloc>;   template class future; template class future<R&>; template<> class future;   template class shared_future; template class shared_future<R&>; template<> class shared_future;   template class packaged_task; // not defined template<class R, class... ArgTypes> class packaged_task<R(ArgTypes...)>;   template<class R, class... ArgTypes> void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;   template<class F, class... Args> future<invoke_result_t<decay_t, decay_t...>> async(F&& f, Args&&... args); template<class F, class... Args> future<invoke_result_t<decay_t, decay_t...>> async(launch policy, F&& f, Args&&... args); }

[edit] Class std::future_error

namespace std { class future_error : public logic_error { public: explicit future_error(future_errc e);   const error_code& code() const noexcept; const char* what() const noexcept;   private: error_code ec_; // exposition only }; }

[edit] Class template std::promise

namespace std { template class promise { public: promise(); template promise(allocator_arg_t, const Allocator& a); promise(promise&& rhs) noexcept; promise(const promise&) = delete; ~promise();   // assignment promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise&) = delete; void swap(promise& other) noexcept;   // retrieving the result future get_future();   // setting the result void set_value(/* see description /); void set_exception(exception_ptr p);   // setting the result with deferred notification void set_value_at_thread_exit(/ see description */); void set_exception_at_thread_exit(exception_ptr p); };   template void swap(promise& x, promise& y) noexcept;   template<class R, class Alloc> struct uses_allocator<promise, Alloc>; }

[edit] Class template std::future

namespace std { template class future { public: future() noexcept; future(future&&) noexcept; future(const future&) = delete; ~future(); future& operator=(const future&) = delete; future& operator=(future&&) noexcept; shared_future share() noexcept;   // retrieving the value /* see description */ get();   // functions to check state bool valid() const noexcept;   void wait() const; template<class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template<class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; }; }

[edit] Class template std::shared_future

namespace std { template class shared_future { public: shared_future() noexcept; shared_future(const shared_future& rhs) noexcept; shared_future(future&&) noexcept; shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs) noexcept; shared_future& operator=(shared_future&& rhs) noexcept;   // retrieving the value /* see description */ get() const;   // functions to check state bool valid() const noexcept;   void wait() const; template<class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template<class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; }; }

[edit] Class template std::packaged_task

namespace std { template class packaged_task; // not defined   template<class R, class... ArgTypes> class packaged_task<R(ArgTypes...)> { public: // construction and destruction packaged_task() noexcept; template explicit packaged_task(F&& f); ~packaged_task();   // no copy packaged_task(const packaged_task&) = delete; packaged_task& operator=(const packaged_task&) = delete;   // move support packaged_task(packaged_task&& rhs) noexcept; packaged_task& operator=(packaged_task&& rhs) noexcept; void swap(packaged_task& other) noexcept;   bool valid() const noexcept;   // result retrieval future get_future();   // execution void operator()(ArgTypes... ); void make_ready_at_thread_exit(ArgTypes...);   void reset(); };   template<class R, class... ArgTypes> packaged_task(R (*)(ArgTypes...)) -> packaged_task<R(ArgTypes...)>;   template packaged_task(F) -> packaged_task</* see description */>;   template<class R, class... ArgTypes> void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept; }