std::experimental::when_all
|
Defined in header
<experimental/future>
|
||
|
template
<
class InputIt >
auto when_all( InputIt first, InputIt last ) |
(1) | (concurrency TS) |
|
template
<
class... Futures
>
auto when_all( Futures&&... futures ) |
(2) | (concurrency TS) |
Create a future object that becomes ready when all of the input futures and shared_futures become ready. The behavior is undefined if any input future or shared_future
In particular, let Sequence be a
std::vector
<
typename
std::iterator_traits
<InputIt>
::
value_type
>
for (1) and
std::tuple
<
std::decay_t
<Futures>...>
for (2). This function template creates a shared state containing Sequence and returns a future referring to the shared state. Every input future is moved into the corresponding object in the Sequence in the shared state, and every input shared_future is copied to the corresponding object in the Sequence in the shared state. The order of the objects in the Sequence
InputIt's value type (i.e.,
typename
std::iterator_traits
<InputIt>
::
value_type
) is a std::experimental::future or std::experimental::shared_future
Fn in Futures, either
std::remove_reference_t<Fn>
is
std::experimental::future
<Rn>
, or std::decay_t<Fn> is
std::experimental::shared_future
<Rn>
After this call, every input future is no longer valid; every input shared_future remains valid.
Return value
A future referring to the shared state created by the call. The future is always valid(), and it becomes ready when all of the input futures and shared_future
future
future<std::tuple<>> is returned and is immediately ready.