class ara::core::Promise

Die Klasse ara::core::Promise fungiert als asynchroner Schreib-Endpunkt, um Werte, Fehler oder Resultate threadübergreifend in einen gemeinsamen Zustand zu übertragen [SWS_CORE_00341]. Der lesende Zugriff erfolgt über ein genau einmalig abrufbares Future, welches bei Bereitstellung des Ergebnisses freigegeben wird [SWS_CORE_00344]. Da die Klasse nicht kopierbar ist, verbleibt der Zustand über Move-Semantik strikt in eindeutigem Besitz, wobei ein mehrfaches Setzen des Ergebnisses oder mehrfaches Abrufen des Futures zu standardisierten Verletzungen führt.

mehr ›

Kontext

Die Klasse ara::core::Promise repräsentiert die Adaptive-Platform-spezifische Ausprägung des aus dem C++-Standard bekannten Konzepts std::promise. Sie ist im Header ara/core/future.h als Template Promise<T, E = ErrorCode> definiert und dient als asynchroner Schreib-Endpunkt eines gemeinsamen Zustands (shared state). Über diesen Kanal übergibt ein Erzeuger threadübergreifend entweder einen berechneten Ausgabewert, einen Fehler oder ein aggregiertes ara::core::Result. Die zugehörige Empfängerseite greift über ein assoziiertes ara::core::Future auf das Resultat zu, welches über die Instanzmethode get_future abgerufen wird [SWS_CORE_00344]. Im Unterschied zum Standard-C++-Mechanismus, der primär auf Ausnahmen basiert, verankert AUTOSAR Adaptive das fehlertypisierte Paradigma: Sofern der Fehlertyp E ungleich ara::core::ErrorCode gewählt wird, erzwingt die Spezifikation einen Übersetzungsfehler.

Lebenszyklus

Eine Instanz wird regulär über den parameterlosen Standardkonstruktor erzeugt, der sich wie der korrespondierende Konstruktor von std::promise verhält, threadsicher ist und einen neuen gemeinsamen Zustand etabliert [SWS_CORE_00341]. Um eindeutige Besitzverhältnisse an diesem Zustand zu garantieren, sind Kopiervorgänge vollständig untersagt: Sowohl der Kopierkonstruktor [SWS_CORE_00350] als auch der Kopierzuweisungsoperator [SWS_CORE_00351] sind als gelöscht (delete) deklariert.

Die Klasse unterstützt jedoch Verschiebesemantik (Move). Der Move-Konstruktor übernimmt den gemeinsamen Zustand der Quellinstanz [SWS_CORE_00342]. Bei einer Move-Zuweisung gibt die Zielinstanz ihren bisherigen gemeinsamen Zustand auf und übernimmt den Zustand des übergebenen Objekts analog zu einem Vertauschungsvorgang [SWS_CORE_00343]. Zusätzlich ermöglicht die Methode swap das Tauschen des internen Zustands mit einer anderen Instanz [SWS_CORE_00352]. Beim Zerstören über den Destruktor wird ein noch gehaltener gemeinsamer Zustand freigegeben bzw. verlassen [SWS_CORE_00349]. Während der Standardkonstruktor threadsicher ausgelegt ist [SWS_CORE_00341], sind Move-Operationen, Zuweisungen, Swap und Zerstörung nicht threadsicher ([SWS_CORE_00342], [SWS_CORE_00343], [SWS_CORE_00352], [SWS_CORE_00349]).

Zustandsdiagramm: Lebenszyklus und Zustandsübergänge des gemeinsamen Zustands in einer Promise-Instanz. Quellen: [SWS_CORE_00341], [SWS_CORE_00342], [SWS_CORE_00343], [SWS_CORE_00344], [SWS_CORE_00345], [SWS_CORE_00349], [SWS_CORE_00353], [SWS_CORE_00355]

Nutzungspfad

Ein typischer Bereitstellungsablauf umfasst folgende Schritte:

1. Erzeugung: Der Erzeuger instantiiert ein ara::core::Promise<T, E> [SWS_CORE_00341].
2. Future abrufen: Vor dem Start der asynchronen Verarbeitung ruft der Erzeuger get_future() auf [SWS_CORE_00344]. Da pro Promise nur ein einziges assoziiertes Future zulässig ist, darf dieser Aufruf exakt einmalig erfolgen. Das zurückgegebene Future wird dem konsumierenden Thread übergeben.
3. Ergebnis setzen: Nach Abschluss der asynchronen Operation überführt der Erzeuger das Resultat in den gemeinsamen Zustand und versetzt diesen in den Zustand ready. Hierfür stehen jeweils threadsichere Überladungen für Kopier- und Verschiebeoperationen bereit:
   • Erfolgreicher Wert: Aufruf von set_value ([SWS_CORE_00345], [SWS_CORE_00346]).
   • Fehlerzustand: Aufruf von SetError ([SWS_CORE_00353], [SWS_CORE_00354]).
   • Kombiniertes Ergebnis: Aufruf von SetResult ([SWS_CORE_00355], [SWS_CORE_00356]).

Sequenzdiagramm: Aufruf- und Synchronisationsabfolge zwischen Erzeuger, Promise, Shared State und Verbraucher. Quellen: [SWS_CORE_00341], [SWS_CORE_00344], [SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]

Fehlerszenarien

Die Spezifikation definiert strenge Vorbedingungen für alle Interaktionen mit dem gemeinsamen Zustand, deren Nichtbeachtung zu standardisierten Verletzungen (Violations) führt:

• Mehrfachabruf des Futures: Wird get_future() mehr als einmal für denselben gemeinsamen Zustand aufgerufen, tritt die Verletzung IsoStdFutureErrcFutureAlreadyRetrievedViolation auf [SWS_CORE_00344].
• Fehlender Shared State: Besitzt die aufgerufene Instanz keinen gemeinsamen Zustand – beispielsweise nach Durchführung einer Move-Operation –, führt get_future() zu IsoStdFutureErrcNoStateViolation [SWS_CORE_00344]. Die Methoden set_value, SetError und SetResult lösen in diesem Fall die Verletzung PromiseNoSharedStateToSetViolation aus ([SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]).
• Bereits erfüllter Zustand: Wurde der gemeinsame Zustand bereits mit einem Wert, Fehler oder Resultat belegt, führt jeder erneute Aufruf von set_value ([SWS_CORE_00345], [SWS_CORE_00346]), SetError ([SWS_CORE_00353], [SWS_CORE_00354]) oder SetResult ([SWS_CORE_00355], [SWS_CORE_00356]) zur Verletzung IsoStdFutureErrcPromiseAlreadySatisfiedViolation.
• Ausnahmesicherheit: Die Methoden set_value, SetError und SetResult sind bedingt ausnahmesicher (conditionally exception safe). Sie werfen keine Ausnahmen, sofern die Konstruktoren der Typen T und E als nothrow deklariert sind ([SWS_CORE_00345], [SWS_CORE_00353], [SWS_CORE_00355]).

Interpretation: Das Aufgeben des gemeinsamen Zustands bei der Zerstörung der Instanz ohne vorherige Wertzuweisung ([SWS_CORE_00349]) dürfte analog zum C++-Standardverhalten von std::promise dazu führen, dass ein assoziiertes Future beim Leseversuch ein entsprechendes Fehlerereignis registriert. Frage Q-fd013bb17a591af9 (offen)