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

La spécialisation ara::core::Promise< void, E > sert de point de terminaison producteur asynchrone pour signaler l'achèvement d'une opération sans valeur de retour ou pour transmettre une erreur ([SWS_CORE_06341]). Après l'instanciation, le Future associé pour le consommateur est récupéré exactement une fois via get_future() ([SWS_CORE_06344]). La mise à disposition s'effectue de manière thread-safe par set_value(), SetError() ou SetResult(), ce qui marque l'état partagé comme prêt. La classe possédant une sémantique de déplacement pur, des définitions multiples ou l'absence d'états partagés conduisent à des violations spécifiées.

plus ›

Contexte

La classe ara::core::Promise< void, E > représente une spécialisation de modèle pour les processus asynchrones sans valeur de données utiles (type de retour void). Elle constitue le côté producteur (Producer) d'un canal de communication et synchronise les calculs ou opérations asynchrones avec le côté consommateur (Consumer). Via un état interne partagé (Shared State), elle permet de signaler soit la réalisation réussie d'une opération, soit la survenue d'une erreur de type E. L'objet récepteur correspondant est mis à disposition sous la forme de ara::core::Future< void, E > ([SWS_CORE_06344]). Selon les exigences de l'AUTOSAR Adaptive Platform, l'implémentation requiert que le type d'erreur E soit compatible avec ara::core::ErrorCode ; tout écart conduit à une erreur lors de la compilation.

Cycle de vie

La création d'une instance s'effectue via le constructeur par défaut sans paramètre [SWS_CORE_06341], qui crée un nouvel état partagé et se comporte de manière analogue à la fonction standard C++ std::promise. La classe modélise une propriété exclusive et implémente une sémantique de déplacement stricte : le constructeur de copie ([SWS_CORE_06350]) ainsi que l'opérateur d'assignation par copie ([SWS_CORE_06351]) sont tous deux supprimés (delete).

Un état existant peut être transféré à d'autres instances via le constructeur de déplacement ([SWS_CORE_06342]) ou l'opérateur d'assignation par déplacement ([SWS_CORE_06343]). Lors de l'assignation par déplacement, un Shared State détenu jusqu'alors est abandonné et l'état est transféré comme par Promise(std::move(other)).swap(*this) ([SWS_CORE_06343]). De plus, la fonction swap ([SWS_CORE_06352]) permet l'échange direct de deux états.

Le destructeur [SWS_CORE_06349] libère un éventuel Shared State encore détenu. Interpretation : l'abandon prématuré du Shared State lors de la destruction d'une promesse non encore satisfaite devrait conduire à un état orphelin dans le future lié. Question Q-e89b32fa3e5994e2 (ouverte) En ce qui concerne la concurrence, la création standard ([SWS_CORE_06341]) ainsi que la définition du résultat ([SWS_CORE_06345], [SWS_CORE_06353], [SWS_CORE_06354], [SWS_CORE_06355], [SWS_CORE_06356]) sont thread-safe. En revanche, les opérations de déplacement, swap, la récupération du future ([SWS_CORE_06344]) et la destruction ne sont pas thread-safe et requièrent une coordination externe en cas d'accès partagé.

Parcours d'utilisation

L'utilisation typique de ara::core::Promise< void, E > comprend la préparation de l'exécution asynchrone, la transmission du canal de réception et la notification consécutive du résultat :

1. Initialisation : le producteur instancie l'objet promise ([SWS_CORE_06341]).
2. Récupérer le future : via get_future(), le ara::core::Future< void, E > lié est créé exactement une fois ([SWS_CORE_06344]) et transmis au côté consommateur.
3. Définir le résultat : après l'achèvement de l'opération asynchrone, le producteur place l'état partagé dans l'état prêt (ready) :
   • En cas de succès, par un appel de set_value() sans argument ([SWS_CORE_06345]).
   • En cas d'erreur, en enregistrant une erreur via SetError, soit par déplacement ([SWS_CORE_06353]), soit par copie ([SWS_CORE_06354]).
   • Alternativement, par la transmission d'un Result< void, E > complet au moyen de SetResult par copie ([SWS_CORE_06355]) ou déplacement ([SWS_CORE_06356]).
4. Résolution : dès que l'état est prêt, le consommateur peut consommer le résultat via le future ; l'objet promise est libéré à la fin de sa portée ([SWS_CORE_06349]).

Diagramme de séquence : déroulement typique de la synchronisation asynchrone, de la création à la mise à disposition du résultat. Sources : [SWS_CORE_06341], [SWS_CORE_06344], [SWS_CORE_06345], [SWS_CORE_06349]

Scénarios d'erreur

Les violations des préconditions conduisent à des situations d'erreur définies (Violations) :

• IsoStdFutureErrcFutureAlreadyRetrievedViolation : est déclenchée si get_future() est appelée plusieurs fois pour le même état partagé ([SWS_CORE_06344]).
• IsoStdFutureErrcNoStateViolation : se produit lorsque get_future() est appelée sans que la promesse ne dispose d'un état partagé ([SWS_CORE_06344]), par exemple après une opération de déplacement ([SWS_CORE_06342]).
• IsoStdFutureErrcPromiseAlreadySatisfiedViolation : survient si set_value() ([SWS_CORE_06345]), SetError() ([SWS_CORE_06353], [SWS_CORE_06354]) ou SetResult() ([SWS_CORE_06355], [SWS_CORE_06356]) est appelée alors qu'une valeur ou une erreur est déjà stockée dans le Shared State.
• PromiseNoSharedStateToSetViolation : signale que set_value() ([SWS_CORE_06345]), SetError() ([SWS_CORE_06353], [SWS_CORE_06354]) ou SetResult() ([SWS_CORE_06355], [SWS_CORE_06356]) ont été appelées sans état partagé existant.

En ce qui concerne la sécurité vis-à-vis des exceptions, les méthodes SetError et SetResult sont conditionnellement sûres vis-à-vis des exceptions (conditionally exception safe) : elles ne garantissent noexcept que si le type E est classé comme constructible par déplacement sans exception (nothrow-move-constructible) ou constructible par copie sans exception (nothrow-copy-constructible) ([SWS_CORE_06353], [SWS_CORE_06354], [SWS_CORE_06355], [SWS_CORE_06356]).