Documentation Home >> Headers >> <future> Header >> jss::when_all function template

jss::when_all combines a set of futures into a single future that becomes ready when all of the futures in the set become ready. For the Concurrency TS version of this function, which includes an additional overload, see the std::experimental::when_all function template and std::experimental::when_all function template (iterator overload) documentation.

template<typename ... FutureTypes>
std::future<std::tuple<FutureTypes...> >
when_all(FutureTypes&&... futures);

Preconditions:

Each type in FutureTypes is an instantiation of either std::future or std::shared_future. For each value in futures a call to valid() must return true. All future which is an instantation of std::future must be passed as an rvalue.

Effects:

The supplied futures are transferred into internal storage. The asynchronous result associated with each future is marked so that when all the futures are ready the future returned from when_all is ready. If all the futures are already ready at the point of the call, the returned future will also be ready.

Returns:

A std::future<std::tuple<FutureTypes> > which becomes ready when all of the supplied futures becomes ready. When the future is ready, the stored value is a std::tuple holding the supplied futures.

Synchronization:

The marking of the individual futures as ready synchronizes with any call to wait() or get() on the returned future that sees the result as ready.

Throws:

std::bad_alloc if the required internal storage cannot be allocated.

Note:

On compilers that don't support variadic templates, an overloaded set of function templates is provided that supports passing of up to 5 arguments.

Note:

On compilers that don't provide std::tuple, jss::tuple is used instead. The macro _JSS_STD_TUPLE is defined to either std::tuple or jss::tuple as appropriate.

Header

#include <future>

See Also