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

Die Elementfunktion get der Spezialisierung ara::core::Future<void, E> dient dem Warten auf das Ergebnis einer asynchronen Operation ohne Rückgabewert ([SWS_CORE_06226]). Sie verhält sich wie die entsprechende Funktion von std::future und blockiert den Aufrufer, bis das Ergebnis oder ein Fehler bereitsteht ([SWS_CORE_06226], [SWS_CORE_00336]). Nach dem Aufruf verliert die Future-Instanz ihre Gültigkeit, sodass valid() == false gilt ([SWS_CORE_06226]).

Die Funktion ist nicht ausnahmesicher (not exception safe) deklariert ([SWS_CORE_06226]). Wurde im verknüpften Promise ein Fehler hinterlegt, wird eine entsprechende Ausnahme ausgelöst ([SWS_CORE_06226]). Wurde der gemeinsame Zustand vorzeitig aufgegeben, tritt der Fehlercode kBrokenPromise gemäß [SWS_CORE_00400] auf ([SWS_CORE_06226]). Wird get auf einer bereits ungültigen Instanz ausgeführt, wirft die Funktion eine FutureException mit dem Fehlercode kNoState ([SWS_CORE_06226]).

Hinsichtlich der Nebenläufigkeit ist die Methode nicht threadsicher (not thread-safe) ([SWS_CORE_06226]). Parallele Zugriffe auf dasselbe Objekt bedürfen daher einer externen Synchronisation. Des Weiteren nimmt die Funktion nicht an der Überladungsauflösung teil, wenn C++-Ausnahmen in der Compiler-Toolchain deaktiviert sind ([SWS_CORE_06226]).

Im Zusammenspiel mit verwandten Funktionen stellt [SWS_CORE_00332] (is_ready) sicher, dass get garantiert nicht blockiert, falls die Operation bereits fertiggestellt ist. Für Kontexte ohne Ausnahmen bietet AUTOSAR als Alternative [SWS_CORE_00336] (GetResult), welches Fehler über einen Ergebnis-Typ zurückmeldet, anstatt Ausnahmen zu werfen.

Verwendung

Die Methode then registriert eine Folgeoperation (Continuation func) an einer ara::core::Future<void, E>-Instanz [SWS_CORE_06231]. Das aufrufbare Objekt nimmt das Ergebnis der Operation als Rvalue-Ausdruck vom Typ Result<void, E> entgegen, welches intern über GetResult bereitgestellt wird [SWS_CORE_06231]. Der Aufruf von func kann synchron im Kontext von then oder asynchron im Kontext von Promise::set_value(), Promise::SetError() beziehungsweise an anderer Stelle erfolgen [SWS_CORE_06231].

Unmittelbar nach Rückkehr von then ist das ursprüngliche Future ungültig (valid() == false) [SWS_CORE_06231]. Der Rückgabetyp passt sich dem Rückgabetyp U der Continuation an:

• Gibt func ein Future<T2, E2> zurück, erfolgt ein implizites Entpacken und then gibt Future<T2, E2> zurück [SWS_CORE_06231].
• Gibt func ein Result<T2, E2> zurück, wird dieses ebenfalls implizit zu Future<T2, E2> entpackt [SWS_CORE_06231].
• In allen anderen Fällen ist der Rückgabetyp Future<U, E> [SWS_CORE_06231].

Fehlerbehandlung und Randbedingungen

Standardisierte Fehlercodes sind für diese Funktion nicht spezifiziert [SWS_CORE_06231]. Die Methode ist als noexcept deklariert, definiert jedoch zwei Verletzungen (Violations):

• FutureInvalidViolation: Tritt auf, wenn die Methode auf einem ungültigen Future aufgerufen wird (falls valid() false zurückgibt) [SWS_CORE_06231].
• FutureContinuationHasThrownViolation: Tritt auf, wenn die Continuation eine Ausnahme wirft, die keine Violation implementiert [SWS_CORE_06231]. Fehler in der Continuation müssen stattdessen in ein Result oder Future verpackt zurückgegeben werden [SWS_CORE_06231].

Nebenläufigkeit und Zusammenspiel

Die Methode ist nicht threadsicher (not thread-safe) [SWS_CORE_06231]. Nach Rückkehr des Destruktors des zurückgegebenen Futures wird keine registrierte Continuation mehr ausgeführt; eine bereits laufende Ausführung wird jedoch zu Ende geführt, sodass der Destruktor blockieren kann [SWS_CORE_06231]. Während [SWS_CORE_06231] für Future<void, E> gilt, beschreibt [SWS_CORE_00331] die Variante für typisierte Futures Future<T, E> und [SWS_CORE_06237] die Überladung mit explizitem Executor.

Die Funktion then registriert ein aufrufbares Fortsetzungsobjekt (Continuation) func an einer Instanz von ara::core::Future<void, E> zur Ausführung im angegebenen Ausführungskontext executor [SWS_CORE_06237]. Unmittelbar nach der Rückgabe von then verliert die aufrufende Future-Instanz ihre Gültigkeit, sodass valid() == false ist [SWS_CORE_06237]. Die Fortsetzung erhält das Ergebnis der ursprünglichen Future-Instanz als Result<void, E> in Form eines Rvalue-Ausdrucks übergeben [SWS_CORE_06237]. Als Rückgabewert liefert der Aufruf eine neue Future-Instanz, wobei Rückgabetypen der Fortsetzung vom Typ Future<T2, E2> oder Result<T2, E2> implizit zu Future<T2, E2> entpackt werden; andernfalls wird ein Future<U, E> zurückgegeben [SWS_CORE_06237].

In Bezug auf Nebenläufigkeit und Lebenszyklus ist die Funktion als nicht threadsicher (not thread-safe) spezifiziert [SWS_CORE_06237]. Die Fortsetzung wird in dem neu zurückgegebenen Future registriert. Nach Rückkehr des Destruktors dieses neuen Futures darf keine Fortsetzung mehr ausgeführt werden; eine bereits in Ausführung befindliche Fortsetzung läuft jedoch vollständig zu Ende, weshalb der Destruktor des Futures blockieren kann [SWS_CORE_06237].

Die Funktion deklariert keine standardisierten Fehlercodes und ist als noexcept definiert [SWS_CORE_06237]. Wird sie auf einer ungültigen Future-Instanz aufgerufen, liegt die Verletzung FutureInvalidViolation vor [SWS_CORE_06237]. Sofern die Fortsetzung eine Exception wirft, führt dies zur Verletzung FutureContinuationHasThrownViolation [SWS_CORE_06237]. Exceptions dürfen die Fortsetzung nicht verlassen, sondern müssen bei Bedarf in Fehlerwerte übersetzt und innerhalb eines Result oder Future zurückgegeben werden [SWS_CORE_06237]. Die Funktion ergänzt die executorlose Variante [SWS_CORE_06231] und bildet das Gegenstück zu den wertbehafteten Überladungen [SWS_CORE_00331] sowie [SWS_CORE_00337].

Die Funktion valid() prüft synchron, ob die Instanz von ara::core::Future<void, E> einen gemeinsamen Zustand (Shared State) besitzt und damit verwendbar ist [SWS_CORE_06227]. Sie verhält sich gemäß Spezifikation analog zur entsprechenden Funktion aus std::future [SWS_CORE_06227]. Als Rückgabewert liefert sie true, wenn das Future nutzbar ist, und false, wenn es nicht nutzbar ist [SWS_CORE_06227].

Hinsichtlich der Nebenläufigkeit und Fehlerbehandlung ist die Methode als noexcept deklariert, ausnahmesicher (exception safe) und ausdrücklich als thread-sicher (thread-safe) spezifiziert [SWS_CORE_06227]. Sie kann somit sicher aus nebenläufigen Kontexten aufgerufen werden.

Im Zusammenspiel mit anderen Operationen dient valid() zur Absicherung des Lebenszyklus:

• Wird auf einem ungültigen Future-Objekt (valid() == false) eine Operation wie wait() [SWS_CORE_06228] oder is_ready() [SWS_CORE_00332] aufgerufen, löst dies die Verletzung FutureInvalidViolation aus.
• Konsumierende Operationen invalidieren das Objekt: Nach einem Aufruf von get() ist das Future nicht mehr gültig, sodass nachfolgende Prüfungen mit valid() den Wert false ergeben [SWS_CORE_06226].
• Ebenso führen Weiterleitungen über then() [SWS_CORE_00331] oder Aufrufe von GetResult() [SWS_CORE_00336] dazu, dass das ursprüngliche Future-Objekt unmittelbar invalidiert wird.

Die Elementfunktion wait der Spezialisierung ara::core::Future<void, E> blockiert den aufrufenden Thread synchron, bis das Ergebnis der asynchronen Operation in Form eines Werts oder eines Fehlers verfügbar ist [SWS_CORE_06228]. Die Funktion nimmt keine Parameter entgegen, liefert keinen Rückgabewert (void) und verhält sich spezifikationsgemäß wie die entsprechende Funktion von std::future [SWS_CORE_06228].

Hinsichtlich Fehlerbehandlung und Randbedingungen gelten folgende Vorgaben:

• Ausnahmesicherheit und Fehlerbehandlung: Die Operation ist mit noexcept deklariert und als ausnahmesicher (exception safe) spezifiziert [SWS_CORE_06228]. Liefert valid() für die Future-Instanz false, liegt die Verletzung FutureInvalidViolation vor [SWS_CORE_06228]. Die konkrete Folge dieser Verletzung dürfte als systemspezifische Fehlerbehandlung der AUTOSAR-Laufzeitumgebung realisiert sein. Frage Q-469e9abc947b9869 (offen)
• Nebenläufigkeit: Die Funktion ist als nicht threadsicher (not thread-safe) eingestuft [SWS_CORE_06228]. Ein nebenläufiger Zugriff auf dasselbe Future-Objekt ohne externe Synchronisation ist daher unzulässig.

Im Zusammenspiel mit den weiteren Funktionen des Moduls core bestehen folgende Möglichkeiten:

• Mit der threadsicheren Methode is_ready kann vorab abgefragt werden, ob die Operation abgeschlossen ist; bei Rückgabe von true blockiert wait garantiert nicht mehr [SWS_CORE_06232].
• Zur Vermeidung endlosen Blockierens stehen die zeitbegrenzten Funktionen wait_for mit einer relativen Dauer [SWS_CORE_06229] sowie wait_until mit einem absoluten Zeitpunkt [SWS_CORE_06230] bereit.
• Für die primäre Template-Klasse ara::core::Future gelten die gleichen synchronen Wartevorgaben und Einschränkungen [SWS_CORE_00328].

Die Methode wait_for der Spezialisierung ara::core::Future<void, E> blockiert den aufrufenden Thread synchron für eine maximale Zeitspanne timeoutDuration oder bis das Ergebnis bereitsteht [SWS_CORE_06229]. Sie verhält sich semantisch wie die korrespondierende Standardfunktion std::future::wait_for [SWS_CORE_06229].

Als Rückgabewert liefert die Funktion den Status FutureStatus [SWS_CORE_06229]. Dieser signalisiert mit FutureStatus::kReady, dass ein Wert oder ein Fehler verfügbar ist, beziehungsweise mit FutureStatus::kTimeout, dass die Frist ohne Ergebnis abgelaufen ist [SWS_CORE_00361]. Ein zu std::future_status::deferred äquivalenter Zustand ist nicht vorgesehen [SWS_CORE_00361]. Das Verhalten entspricht der allgemeinen Future-Schnittstelle [SWS_CORE_00329].

Für den Aufruf gelten folgende Bedingungen bezüglich Nebenläufigkeit und Fehlerbehandlung:

• Nebenläufigkeit: Die Funktion ist als nicht threadsicher (not thread-safe) spezifiziert [SWS_CORE_06229]. Gleichzeitige Aufrufe auf derselben Instanz müssen aufruferseitig abgesichert werden.
• Fehlerfälle und Ausnahmesicherheit: Die Operation ist als ausnahmesicher (exception safe) sowie noexcept deklariert [SWS_CORE_06229]. Ist das Future-Objekt ungültig (valid() liefert false), liegt eine FutureInvalidViolation vor [SWS_CORE_06229]. Wegen der noexcept-Deklaration dürfte diese Verletzung vermutlich zum sofortigen Programmabbruch führen. Frage Q-4f01aa6e7fbfb12d (offen)

Die Elementfunktion wait_until der Spezialisierung ara::core::Future<void, E> blockiert den aufrufenden Thread, bis der angegebene absolute Zeitpunkt deadline erreicht ist oder ein Wert beziehungsweise ein Fehler zur Verfügung steht [SWS_CORE_06230]. Die Funktion zeigt dasselbe Verhalten wie die korrespondierende C++-Standardfunktion std::future::wait_until [SWS_CORE_06230] und besitzt die gleiche Semantik wie die generische Überladung für ara::core::Future [SWS_CORE_00330].

Der Rückgabewert vom Typ FutureStatus signalisiert, ob die Frist erreicht wurde oder ein Wert verfügbar ist [SWS_CORE_06230]. Hierbei zeigt der Zustand kReady an, dass der geteilte Status bereit ist, während kTimeout bedeutet, dass der geteilte Status vor Ablauf der Frist nicht bereit wurde [SWS_CORE_00361]. Ein Zustand analog zu std::future_status::deferred existiert in FutureStatus nicht [SWS_CORE_00361].

Hinsichtlich Ausführung und Randbedingungen sind folgende Vorgaben definiert:

• Aufrufkontext und Ausnahmeverhalten: Die Funktion ist über die Header-Datei #include "ara/core/future.h" verfügbar, als noexcept deklariert und als ausnahmesicher (exception safe) spezifiziert [SWS_CORE_06230].
• Fehlerzustände: Ist das Future ungültig, wenn also valid() den Wert false zurückgibt, liegt die Verletzung FutureInvalidViolation vor [SWS_CORE_06230].
• Nebenläufigkeit: Die Operation ist als nicht threadsicher (not thread-safe) eingestuft [SWS_CORE_06230].