Namespaces
Variants

std::experimental:: when_any

From cppreference.net
C++
Experimental
Extensions for concurrency
Défini dans l'en-tête <experimental/future>
template < class Sequence >

struct when_any_result {
std:: size_t index ;
Sequence futures ;

} ;
(concurrency TS)
template < class InputIt >

auto when_any ( InputIt first, InputIt last )

- > future < when_any_result < std:: vector < typename std:: iterator_traits < InputIt > :: value_type >>> ;
(1) (concurrency TS)
template < class ... Futures >

auto when_any ( Futures && ... futures )

- > future < when_any_result < std:: tuple < std:: decay_t < Futures > ... >>> ;
(2) (concurrency TS)

Créez un objet future qui devient prêt lorsqu'au moins une des future s et shared_future s d'entrée devient prête. Le comportement est indéfini si une future ou shared_future d'entrée est invalide.

En particulier, soit Sequence un std:: vector < typename std:: iterator_traits < InputIt > :: value_type > pour (1) et std:: tuple < std:: decay_t < Futures > ... > pour (2) . Ce modèle de fonction crée un état partagé contenant when_any_result<Sequence> et retourne un futur référençant cet état partagé. Chaque future d'entrée est déplacé dans l'objet correspondant du membre futures du when_any_result<Sequence> dans l'état partagé, et chaque shared_future d'entrée est copié dans l'objet correspondant du membre futures du when_any_result<Sequence> dans l'état partagé. L'ordre des objets dans la Sequence correspond à l'ordre des arguments.

1) Cette fonction ne participe pas à la résolution de surcharge sauf si InputIt 's value type (c'est-à-dire, typename std:: iterator_traits < InputIt > :: value_type ) est un std::experimental::future ou un std::experimental::shared_future .
2) Cette fonction ne participe pas à la résolution de surcharge sauf si chaque argument est soit un std::experimental::shared_future (éventuellement qualifié cv), soit un std::experimental::future non qualifié cv. (Formellement, pour chaque type Fn dans Futures , soit std:: remove_reference_t < Fn > est std:: experimental :: future < Rn > , soit std:: decay_t < Fn > est std:: experimental :: shared_future < Rn > .)

Après cet appel, chaque future d'entrée n'est plus valide ; chaque shared_future d'entrée reste valide.

Valeur de retour

Un future faisant référence à l'état partagé créé par l'appel. Le futur est toujours valid ( ) , et il devient prêt lorsqu'au moins un des future s ou shared_future s en entrée de l'appel est prêt. Le membre index du when_any_result contient la position du future ou du shared_future prêt dans le membre futures .

1) Si la plage est vide (c'est-à-dire, first == last ), le future retourné est immédiatement prêt ; le champ futures du when_any_result est un vecteur vide, et le champ index est size_t ( - 1 ) .
2) Si aucun argument n'est fourni, le future retourné est prêt immédiatement ; le champ futures du when_any_result est un tuple vide, et le champ index est size_t ( - 1 ) .