std::experimental::when_any combines a set of futures
into a single future that becomes ready when any of
the futures in the set become ready.
template<typename ... FutureTypes> std::experimental::future<std::experimental::when_any_result<std::tuple<FutureTypes...> > > when_any(FutureTypes&&... futures);
Each type in
is an instantiation of either
std::experimental::shared_future. For each
a call to
future which is an instantation of
std::experimental::future must be passed as
The supplied futures are transferred into internal storage. The asynchronous
result associated with each future is marked so that when any of
the futures are ready the future returned from
when_any is ready.
If any of the futures are already ready at the
point of the call, the returned future will also be ready.
which becomes ready when any of the supplied
futures becomes ready. When the future is ready,
the stored value's
member is a
std::tuple holding the supplied
futures, and the
index member holds the index of
the future that caused the result to become 'ready.
The marking of the first future as ready synchronizes
with any call to
get() on the returned future that sees
the result as ready.
std::bad_alloc if the required internal
storage cannot be allocated.