classe ara::core::Future< void, E >

La fonction membre get de la spécialisation ara::core::Future<void, E> sert à attendre le résultat d'une opération asynchrone sans valeur de retour ([SWS_CORE_06226]). Elle se comporte comme la fonction correspondante de std::future et bloque l'appelant jusqu'à ce que le résultat ou une erreur soit disponible ([SWS_CORE_06226], [SWS_CORE_00336]). Après l'appel, l'instance de future perd sa validité, de sorte que valid() == false s'applique ([SWS_CORE_06226]).

La fonction est déclarée non sûre vis-à-vis des exceptions (not exception safe) ([SWS_CORE_06226]). Si une erreur a été consignée dans le Promise associé, une exception correspondante est déclenchée ([SWS_CORE_06226]). Si l'état partagé a été abandonné prématurément, le code d'erreur kBrokenPromise selon [SWS_CORE_00400] survient ([SWS_CORE_06226]). Si get est exécutée sur une instance déjà invalide, la fonction lève une FutureException avec le code d'erreur kNoState ([SWS_CORE_06226]).

En matière de concurrence, la méthode n'est pas thread-safe (not thread-safe) ([SWS_CORE_06226]). Les accès parallèles au même objet nécessitent donc une synchronisation externe. De plus, la fonction ne participe pas à la résolution de surcharge lorsque les exceptions C++ sont désactivées dans la chaîne d'outils du compilateur ([SWS_CORE_06226]).

En interaction avec des fonctions apparentées, [SWS_CORE_00332] (is_ready) garantit que get ne bloque pas si l'opération est déjà terminée. Pour les contextes sans exceptions, AUTOSAR propose comme alternative [SWS_CORE_00336] (GetResult), qui signale les erreurs via un type de résultat au lieu de lever des exceptions.

Utilisation

La méthode then enregistre une opération consécutive (continuation func) sur une instance de ara::core::Future<void, E> [SWS_CORE_06231]. L'objet appelable reçoit le résultat de l'opération sous la forme d'une expression rvalue de type Result<void, E>, fournie en interne via GetResult [SWS_CORE_06231]. L'appel de func peut s'effectuer de manière synchrone dans le contexte de then ou de manière asynchrone dans le contexte de Promise::set_value(), de Promise::SetError() ou ailleurs [SWS_CORE_06231].

Immédiatement après le retour de then, le future d'origine est invalide (valid() == false) [SWS_CORE_06231]. Le type de retour s'adapte au type de retour U de la continuation :

• Si func renvoie un Future<T2, E2>, un déballage implicite a lieu et then renvoie Future<T2, E2> [SWS_CORE_06231].
• Si func renvoie un Result<T2, E2>, celui-ci est également déballé implicitement en Future<T2, E2> [SWS_CORE_06231].
• Dans tous les autres cas, le type de retour est Future<U, E> [SWS_CORE_06231].

Gestion des erreurs et conditions limites

Aucun code d'erreur standardisé n'est spécifié pour cette fonction [SWS_CORE_06231]. La méthode est déclarée comme noexcept, mais définit deux violations (violations) :

• FutureInvalidViolation : survient lorsque la méthode est appelée sur un future invalide (si valid() renvoie false) [SWS_CORE_06231].
• FutureContinuationHasThrownViolation : survient lorsque la continuation lève une exception qui n'implémente pas une violation [SWS_CORE_06231]. Les erreurs dans la continuation doivent être renvoyées à la place encapsulées dans un Result ou un Future [SWS_CORE_06231].

Concurrence et interaction

La méthode n'est pas thread-safe (not thread-safe) [SWS_CORE_06231]. Après le retour du destructeur du future renvoyé, plus aucune continuation enregistrée n'est exécutée ; toutefois, une exécution déjà en cours est menée à son terme, de sorte que le destructeur peut bloquer [SWS_CORE_06231]. Tandis que [SWS_CORE_06231] s'applique à Future<void, E>, [SWS_CORE_00331] décrit la variante pour les futures typés Future<T, E> et [SWS_CORE_06237] la surcharge avec un exécuteur explicite.

La fonction then enregistre un objet de continuation appelable func sur une instance de ara::core::Future<void, E> pour exécution dans le contexte d'exécution spécifié executor [SWS_CORE_06237]. Immédiatement après le retour de then, l'instance de future appelante perd sa validité, de sorte que valid() == false est vérifié [SWS_CORE_06237]. La continuation reçoit le résultat de l'instance de future d'origine passé comme Result<void, E> sous forme d'une expression rvalue [SWS_CORE_06237]. Comme valeur de retour, l'appel fournit une nouvelle instance de Future, les types de retour de la continuation de type Future<T2, E2> ou Result<T2, E2> étant implicitement déballés en Future<T2, E2> ; sinon, un Future<U, E> est retourné [SWS_CORE_06237].

En matière de concurrence et de cycle de vie, la fonction est spécifiée comme n'étant pas thread-safe (not thread-safe) [SWS_CORE_06237]. La continuation est enregistrée dans le nouveau future retourné. Après le retour du destructeur de ce nouveau future, aucune continuation ne doit plus être exécutée ; une continuation déjà en cours d'exécution s'exécute toutefois complètement jusqu'à son terme, raison pour laquelle le destructeur du future peut bloquer [SWS_CORE_06237].

La fonction ne déclare aucun code d'erreur standardisé et est définie comme noexcept [SWS_CORE_06237]. Si elle est appelée sur une instance de future non valide, la violation FutureInvalidViolation se produit [SWS_CORE_06237]. Dans la mesure où la continuation lève une exception, cela conduit à la violation FutureContinuationHasThrownViolation [SWS_CORE_06237]. Les exceptions ne doivent pas quitter la continuation, mais doivent être traduites au besoin en valeurs d'erreur et retournées à l'intérieur d'un Result ou Future [SWS_CORE_06237]. La fonction complète la variante sans exécuteur [SWS_CORE_06231] et constitue le pendant des surcharges avec valeur [SWS_CORE_00331] ainsi que [SWS_CORE_00337].

La fonction valid() vérifie de manière synchrone si l'instance de ara::core::Future<void, E> possède un état partagé (Shared State) et est ainsi utilisable [SWS_CORE_06227]. Conformément à la spécification, elle se comporte de manière analogue à la fonction correspondante de std::future [SWS_CORE_06227]. Comme valeur de retour, elle fournit true si le future est utilisable, et false s'il n'est pas utilisable [SWS_CORE_06227].

En ce qui concerne la concurrence et le traitement des erreurs, la méthode est déclarée comme noexcept, sûre vis-à-vis des exceptions (exception safe) et expressément spécifiée comme thread-safe [SWS_CORE_06227]. Elle peut ainsi être appelée en toute sécurité depuis des contextes concurrents.

En interaction avec d'autres opérations, valid() sert à sécuriser le cycle de vie :

• Si une opération telle que wait() [SWS_CORE_06228] ou is_ready() [SWS_CORE_00332] est appelée sur un objet future non valide (valid() == false), cela déclenche la violation FutureInvalidViolation.
• Les opérations de consommation invalident l'objet : après un appel de get(), le future n'est plus valide, de sorte que les vérifications ultérieures avec valid() donnent la valeur false [SWS_CORE_06226].
• De même, les transmissions via then() [SWS_CORE_00331] ou les appels de GetResult() [SWS_CORE_00336] entraînent l'invalidation immédiate de l'objet future d'origine.

La fonction membre wait de la spécialisation ara::core::Future<void, E> bloque le thread appelant de manière synchrone jusqu'à ce que le résultat de l'opération asynchrone soit disponible sous la forme d'une valeur ou d'une erreur [SWS_CORE_06228]. La fonction ne prend aucun paramètre, ne renvoie aucune valeur de retour (void) et se comporte conformément à la spécification comme la fonction correspondante de std::future [SWS_CORE_06228].

Concernant le traitement des erreurs et les conditions aux limites, les exigences suivantes s'appliquent :

• Sécurité vis-à-vis des exceptions et traitement des erreurs : L'opération est déclarée avec noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06228]. Si valid() renvoie false pour l'instance de future, la violation FutureInvalidViolation est présente [SWS_CORE_06228]. La conséquence concrète de cette violation devrait être mise en œuvre sous forme d'un traitement d'erreurs spécifique au système de l'environnement d'exécution AUTOSAR. Question Q-469e9abc947b9869 (ouverte)
• Concurrence : La fonction est classée comme non thread-safe (not thread-safe) [SWS_CORE_06228]. Un accès concurrent au même objet future sans synchronisation externe est donc inadmissible.

En interaction avec les autres fonctions du module core, les possibilités suivantes existent :

• La méthode thread-safe is_ready permet de vérifier au préalable si l'opération est terminée ; en cas de retour de true, wait est garanti de ne plus bloquer [SWS_CORE_06232].
• Pour éviter un blocage infini, les fonctions limitées dans le temps wait_for avec une durée relative [SWS_CORE_06229] ainsi que wait_until avec un instant absolu [SWS_CORE_06230] sont disponibles.
• Pour la classe de modèle primaire ara::core::Future, les mêmes exigences d'attente synchrone et restrictions s'appliquent [SWS_CORE_00328].

La méthode wait_for de la spécialisation ara::core::Future<void, E> bloque le thread appelant de manière synchrone pendant un laps de temps maximal timeoutDuration ou jusqu'à ce que le résultat soit disponible [SWS_CORE_06229]. Elle se comporte sémantiquement comme la fonction standard correspondante std::future::wait_for [SWS_CORE_06229].

Comme valeur de retour, la fonction fournit l'état FutureStatus [SWS_CORE_06229]. Celui-ci signale avec FutureStatus::kReady qu'une valeur ou une erreur est disponible, ou avec FutureStatus::kTimeout que l'échéance a expiré sans résultat [SWS_CORE_00361]. Un état équivalent à std::future_status::deferred n'est pas prévu [SWS_CORE_00361]. Le comportement correspond à l'interface générale de future [SWS_CORE_00329].

Pour l'appel, les conditions suivantes s'appliquent en matière de concurrence et de traitement des erreurs :

• Concurrence : la fonction est spécifiée comme n'étant pas thread-safe (not thread-safe) [SWS_CORE_06229]. Les appels simultanés sur la même instance doivent être sécurisés du côté de l'appelant.
• Cas d'erreur et sécurité vis-à-vis des exceptions : l'opération est déclarée comme sûre vis-à-vis des exceptions (exception safe) ainsi que noexcept [SWS_CORE_06229]. Si l'objet Future n'est pas valide (valid() fournit false), il y a une FutureInvalidViolation [SWS_CORE_06229]. En raison de la déclaration noexcept, cette violation devrait probablement conduire à un arrêt immédiat du programme. Question Q-4f01aa6e7fbfb12d (ouverte)

La fonction membre wait_until de la spécialisation ara::core::Future<void, E> bloque le thread appelant jusqu'à ce que l'instant absolu spécifié deadline soit atteint ou qu'une valeur ou une erreur soit disponible [SWS_CORE_06230]. La fonction présente le même comportement que la fonction standard C++ correspondante std::future::wait_until [SWS_CORE_06230] et possède la même sémantique que la surcharge générique pour ara::core::Future [SWS_CORE_00330].

La valeur de retour de type FutureStatus signale si l'échéance a été atteinte ou si une valeur est disponible [SWS_CORE_06230]. Ici, l'état kReady indique que l'état partagé est prêt, tandis que kTimeout signifie que l'état partagé n'est pas devenu prêt avant l'expiration de l'échéance [SWS_CORE_00361]. Un état analogue à std::future_status::deferred n'existe pas dans FutureStatus [SWS_CORE_00361].

Concernant l'exécution et les conditions aux limites, les exigences suivantes sont définies :

• Contexte d'appel et comportement vis-à-vis des exceptions : la fonction est disponible via le fichier d'en-tête #include "ara/core/future.h", déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_06230].
• États d'erreur : si le future n'est pas valide, c'est-à-dire si valid() renvoie la valeur false, la violation FutureInvalidViolation est présente [SWS_CORE_06230].
• Concurrence : l'opération est classée comme n'étant pas thread-safe (not thread-safe) [SWS_CORE_06230].