Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::experi...al::when_all(3) C++ Standard Libarystd::experi...al::when_all(3)

NAME
       std::experimental::when_all - std::experimental::when_all

Synopsis
	  Defined in header <experimental/future>
	  template < class InputIt >

	  auto	when_all(InputIt first,	InputIt	last)			   (1)
       (concurrency TS)

	  -> future<std::vector<typename
	  std::iterator_traits<InputIt>::value_type>>;
	  template < class... Futures >

	  auto when_all(Futures&&... futures)				   (2)
       (concurrency TS)

	  -> future<std::tuple<std::decay_t<Futures>...>>;

	  Create  a future object that becomes ready when all of the input fu-
       tures and
	  shared_futures become	ready. The behavior is undefined if any	 input
       future or
	  shared_future	is invalid.

	  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 Se-
       quence in the
	  shared state,	and every input	shared_future is copied	to the	corre-
       sponding	object in
	  the  Sequence	 in  the shared	state. The order of the	objects	in the
       Sequence	matches
	  the order of arguments.

	  1) This function does	not participate	in overload resolution	unless
       InputIt's value
	  type (i.e., typename std::iterator_traits<InputIt>::value_type) is a
	  std::experimental::future or std::experimental::shared_future.
	  2)  This function does not participate in overload resolution	unless
       every argument
	  is either a (possibly	cv-qualified) std::experimental::shared_future
       or a
	  cv-unqualified std::experimental::future. (Formally, for every  type
       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  fu-
       ture is always
	  valid(),  and	 it  becomes  ready  when all of the input futures and
       shared_futures the
	  call are ready.

	  1) If	the range is empty (i.e., first	== last), the returned	future
       contains	an
	  empty	vector and is ready immediately.
	  2) If	there are no arguments supplied, a future<std::tuple<>>	is re-
       turned and is
	  immediately ready.

http://cppreference.com		  2022.07.31	 std::experi...al::when_all(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::experimental::when_all&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help