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

Verwendung und Aufrufkontext

Die Elementfunktion Bind der Spezialisierung ara::core::Result<void, E> aus ara/core/result.h führt eine Folgeberechnung auf einer erfolgreichen Instanz ohne Ergebniswert aus [SWS_CORE_00870]. Ist ein Wert vorhanden, wird das übergebene Callable f synchron und ohne Parameter aufgerufen. Das Callable muss entweder die Schnittstelle Result<XXX, E> f() oder XXX f() erfüllen, wobei XXX ein für Result zulässiger Typ sein muss [SWS_CORE_00870]. Liefert das Callable ein Result, entspricht der Rückgabetyp decltype(f()); gibt es direkt XXX zurück, wird das Ergebnis als Result<decltype(f()), E> verpackt [SWS_CORE_00870].

Fehlerbehandlung und Nebenläufigkeit

Enthält die Instanz keinen Wert, wird ein neues Result<XXX, E> zurückgegeben, in das der ursprüngliche Fehler kopiert wird [SWS_CORE_00870]. Interpretation: In diesem Fall dürfte die Ausführung des Callables f unterbleiben. Frage Q-6288a7106d2730c3 (offen) Hinsichtlich der Ausführungssicherheit gilt die Funktion als not exception safe [SWS_CORE_00870]. Die Thread-Sicherheit ist bedingt (conditional) und hängt vollständig von der Thread-Sicherheit des übergebenen Callables f ab [SWS_CORE_00870].

Zusammenspiel mit verwandten Anforderungen

Im Gegensatz zu den primären Result<T, E>-Funktionen aus [SWS_CORE_00768] und [SWS_CORE_00941], bei denen das Callable den Wert der Instanz per f(const T&) entgegennimmt, bindet die vorliegende Überladung [SWS_CORE_00870] Operationen an void-Ergebnisse und erwartet daher ein parameterloses Callable.

Die Elementfunktion EmplaceError der Spezialisierung ara::core::Result<void, E> konstruiert synchron einen neuen Fehlerwert direkt in-place innerhalb der bestehenden Instanz aus den übergebenen Argumenten args [SWS_CORE_00844]. Die über die Header-Datei ara/core/result.h bereitgestellte Template-Funktion besitzt keinen Rückgabewert und initialisiert das Fehlerobjekt vom Typ E unmittelbar vor Ort [SWS_CORE_00844].

Hinsichtlich der Fehlerbehandlung und Ausnahme-Sicherheit ist die Operation als bedingt ausnahmesicher (conditionally exception safe) eingestuft [SWS_CORE_00844]. Über den Spezifikator noexcept(std::is_nothrow_constructible<E, Args...>::value) wird Ausnahmefreiheit garantiert, sofern der Typ E mit den Typen Args... ohne Exception konstruiert werden kann [SWS_CORE_00844].

In Bezug auf Nebenläufigkeit und Randbedingungen ist die Elementfunktion als nicht threadsicher (not thread-safe) definiert [SWS_CORE_00844]. Wenn mehrere Threads konkurrierend auf dieselbe Result-Instanz zugreifen, ist vermutlich ein externer Synchronisationsmechanismus erforderlich, um unkoordinierte Zustandsänderungen zu verhindern. Frage Q-ffcb8ced860f6080 (offen)

Im Gesamtzusammenhang des Moduls core korrespondiert [SWS_CORE_00844] direkt mit den weiteren Varianten derselben Funktion: Für das primäre Template ara::core::Result ist das identische Verhalten unter [SWS_CORE_00744] spezifiziert, während für Referenz-Typen ara::core::Result<T&, E> die Anforderung [SWS_CORE_00916] dieselbe Signatur und Semantik vorgibt.

Verwendung und Aufrufkontext

Die Template-Elementfunktion EmplaceValue gehört zum Modul core und wird über die Header-Datei #include "ara/core/result.h" für die Spezialisierung ara::core::Result<void, E> definiert [SWS_CORE_00843]. Ihr Zweck ist das direkte Erzeugen bzw. Setzen eines neuen Werts in der bestehenden Instanz anhand der übergebenen Argumente args [SWS_CORE_00843]. Die Ausführung erfolgt synchron und liefert keinen Rückgabewert (void) [SWS_CORE_00843]. Da der Werttyp der Spezialisierung void ist, überführt der Aufruf die Instanz in einen Erfolgszustand; als Interpretation dürfte das Entgegennehmen von args primär der generischen Signaturkompatibilität mit der primären Template-Klasse dienen. Frage Q-b53ca5908f2517fb (offen)

Fehlerbehandlung und Exception-Sicherheit

Die Funktion ist als noexcept deklariert und besitzt die Spezifikation exception safe [SWS_CORE_00843]. Sie gibt keine Fehlercodes zurück und wirft keine Ausnahmen. Befand sich das Result-Objekt zuvor in einem Fehlerzustand, wird dieser durch das Einsetzen des Werts überschrieben.

Nebenläufigkeit und Einschränkungen

Die Operation ist als nicht threadsicher (not thread-safe) ausgewiesen [SWS_CORE_00843]. Bei potenziell nebenläufigen Lese- oder Schreibzugriffen auf dieselbe Instanz von ara::core::Result ist eine externe Synchronisation durch den Aufrufer zwingend erforderlich.

Zusammenspiel mit verwandten Spezifikationen

Im Vergleich zur allgemeinen Implementierung von EmplaceValue für ara::core::Result<T, E> in [SWS_CORE_00743], die nur bedingt ausnahmesicher ist und deren noexcept-Eigenschaft von std::is_nothrow_constructible<T, Args...>::value abhängt, bietet die void-Spezialisierung gemäß [SWS_CORE_00843] eine uneingeschränkte noexcept- und Ausnahmesicherheits-Garantie.

Die Elementfunktion Err() const & der Klassen-Spezialisierung ara::core::Result<void, E> ermöglicht das synchrone Abfragen eines möglicherweise enthaltenen Fehlerzustands ([SWS_CORE_00868]). Sie wird über die Header-Datei ara/core/result.h deklariert und erfordert beim Aufruf keine Übergabeparameter ([SWS_CORE_00868]). Als Rückgabewert liefert die Funktion ein ara::core::Optional<E>, welches den konkreten Fehlerwert enthält, sofern das Objekt einen Fehler repräsentiert ([SWS_CORE_00868]).

In Bezug auf Nebenläufigkeit und Randbedingungen ist die Operation explizit als thread-safe spezifiziert ([SWS_CORE_00868]). Hinsichtlich der Ausnahmesicherheit gilt die Methode als bedingt ausnahmesicher (conditionally exception safe) ([SWS_CORE_00868]). Die noexcept-Garantie greift dabei genau dann, wenn std::is_nothrow_constructible<Optional<E>, const E&>::value erfüllt ist ([SWS_CORE_00868]).

Im Verbund der Schnittstellen ergänzt die rvalue-Überladung Err() && ([SWS_CORE_00869]) diese Funktion innerhalb von ara::core::Result<void, E>. Vergleichbare Paare von lvalue- und rvalue-Überladungen stehen auch für das primäre Template ara::core::Result<T, E> ([SWS_CORE_00772], [SWS_CORE_00773]) sowie für die Referenz-Spezialisierung ara::core::Result<T&, E> ([SWS_CORE_00931], [SWS_CORE_00932]) zur Verfügung.

Die Elementfunktion Err() && der Spezialisierung ara::core::Result< void, E > extrahiert einen eventuell vorhandenen Fehler und liefert ihn als ara::core::Optional< E > zurück [SWS_CORE_00869]. Sie ist über die Header-Datei ara/core/result.h eingebunden [SWS_CORE_00869].

Hinsichtlich Verwendung und Semantik gelten folgende Eigenschaften:

• Aufrufkontext und Parameter: Die Funktion nimmt keine Parameter entgegen und bindet als Rvalue-qualifizierte Methode ausschließlich an Rvalue-Instanzen von ara::core::Result< void, E > [SWS_CORE_00869]. Interpretation: Durch die Rvalue-Semantik (&&) dürfte das Fehlerobjekt beim Aufruf in das zurückgegebene Optional verschoben werden. Frage Q-b5a0098f77686ca6 (offen)
• Rückgabewert: Das resultierende ara::core::Optional< E > enthält den Fehlerwert, sofern ein solcher im Objekt vorhanden ist [SWS_CORE_00869].
• Ausnahmesicherheit und Nebenläufigkeit: Die Operation ist als bedingt ausnahmesicher (conditionally exception safe) eingestuft und wirft keine Ausnahmen, falls std::is_nothrow_constructible< Optional< E >, E && >::value erfüllt ist [SWS_CORE_00869]. Zudem ist die Funktion als threadsicher (thread-safe) spezifiziert [SWS_CORE_00869].

Im Zusammenspiel der Schnittstellen ergänzt diese Rvalue-Variante die entsprechende Lvalue-Überladung Err() const & derselben Spezialisierung [SWS_CORE_00868]. Analoge Paare aus Lvalue- und Rvalue-Methoden existieren für das primäre Template ara::core::Result [SWS_CORE_00772], [SWS_CORE_00773] sowie für die Referenzspezialisierung ara::core::Result< T &, E > [SWS_CORE_00931], [SWS_CORE_00932].

Die Template-Elementfunktion ErrorOr der Spezialisierung ara::core::Result<void, E> dient dem synchronen Abrufen des enthaltenen Fehlers oder eines alternativen Standardfehlers gemäß [SWS_CORE_00863]. Enthält die Instanz bereits einen Fehlerwert vom Typ E, wird dieser unverändert zurückgegeben; andernfalls wird der übergebene Parameter defaultError mittels static_cast in den Fehlertyp E konvertiert und zurückgeliefert [SWS_CORE_00863].

Hinsichtlich Fehlerbehandlung und Nebenläufigkeit gelten folgende Eigenschaften:

• Ausnahmesicherheit: Der Aufruf ist bedingt ausnahmesicher (conditionally exception safe) und als noexcept deklariert, sofern sowohl die Kopierkonstruktion von E als auch die Konstruktion von E aus dem universellen Referenztyp G&& nicht werfend sind (std::is_nothrow_copy_constructible<E>::value && std::is_nothrow_constructible<E, G&&>::value) [SWS_CORE_00863].
• Thread-Sicherheit: Die Operation ist als threadsicher (thread-safe) spezifiziert [SWS_CORE_00863]. Da es sich um eine konstante Lvalue-Referenz-Überladung (const &) handelt, dürften gleichzeitige lesende Zugriffe auf dieselbe Instanz sicher sein. Frage Q-f95402c2e79ef590 (offen)
• Header: Die Funktion wird über die Header-Datei #include "ara/core/result.h" bereitgestellt [SWS_CORE_00863].

Im Zusammenspiel innerhalb von ara::core::Result bildet [SWS_CORE_00863] das lvalue-konstante Gegenstück zur Rvalue-Überladung [SWS_CORE_00864] für void-Ergebnisse, bei welcher der Fehler via std::move übertragen wird. Äquivalente Überladungen existieren für die primäre Klassenvorlage Result<T, E> über [SWS_CORE_00763] und [SWS_CORE_00764] sowie für Referenztypen Result<T &, E> über [SWS_CORE_00935] und [SWS_CORE_00936].

Verwendung und Semantik

Die Elementfunktion ErrorOr der Spezialisierung ara::core::Result<void, E> dient dem synchronen Auslesen eines Fehlers aus einer Rvalue-Instanz ([SWS_CORE_00864]). Wird die Methode aufgerufen und enthält das Result-Objekt einen Fehler, wird dieser mittels std::move in den Rückgabewert vom Typ E verschoben. Liegt hingegen ein erfolgreiches Ergebnis vor, wird das übergebene Argument defaultError per static_cast nach E konvertiert und zurückgegeben ([SWS_CORE_00864]).

Fehlerbehandlung und Exception-Sicherheit

Die Funktion löst selbst keine klassischen AUTOSAR-Fehlermeldungen wie DET oder DEM aus. Hinsichtlich der Ausnahmebehandlung ist ErrorOr bedingt ausnahmesicher (conditionally exception safe). Sie ist über einen noexcept-Ausdruck abgesichert, sofern sowohl der Fehlertyp E ohne Ausnahmen verschiebbar ist (std::is_nothrow_move_constructible<E>::value) als auch E aus dem universellen Referenztyp G&& des Standardfehlers ausnahmefrei konstruiert werden kann ([SWS_CORE_00864]).

Nebenläufigkeit und Zusammenspiel

Die Methode ist als thread-safe spezifiziert ([SWS_CORE_00864]). Durch den Rvalue-Ref-Qualifier && setzt der Aufruf voraus, dass das Result-Objekt als Rvalue übergeben wird.

Im Modul core steht diese Rvalue-Variante im Verbund mit weiteren Ausprägungen:

• Für ara::core::Result<void, E> existiert als Lvalue-Gegenstück die const &-Überladung [SWS_CORE_00863], welche den Fehler kopiert statt verschiebt.
• Für Werte- und Referenzergebnisse bieten die Spezialisierungen ara::core::Result<T, E> ([SWS_CORE_00763], [SWS_CORE_00764]) sowie ara::core::Result<T&, E> ([SWS_CORE_00935], [SWS_CORE_00936]) dieselbe duale Signaturstruktur für Kopier- und Move-Semantik.

Verwendung

Die statische Funktion FromError ist Bestandteil der Template-Spezialisierung ara::core::Result<void, E> und wird über die Header-Datei ara/core/result.h eingebunden [SWS_CORE_00834]. Sie dient als synchrone Factory-Methode, um aus einem bereits existierenden Fehlerobjekt ein neues Result zu konstruieren [SWS_CORE_00834].

• Parameter: Der Eingabeparameter e nimmt den Fehler als konstante Lvalue-Referenz (const E &) entgegen [SWS_CORE_00834].
• Rückgabewert: Gibt eine Instanz von Result zurück, die den übergebenen Fehler e enthält [SWS_CORE_00834].

Fehlerbehandlung und Ausnahme-Sicherheit

Die Spezifikation definiert keine spezifischen Fehlercodes und sieht keine Meldungen an DET oder DEM vor [SWS_CORE_00834]. Die Funktion ist bedingt ausnahmesicher (conditionally exception safe): Sie ist genau dann als noexcept garantiert, wenn der Fehlertyp E nicht-werfend kopierbar ist (std::is_nothrow_copy_constructible<E>::value) [SWS_CORE_00834].

Nebenläufigkeit

Der Aufruf ist als thread-safe eingestuft [SWS_CORE_00834]. Interpretation: Die Thread-Sicherheit dürfte den internen Ablauf der Objekterzeugung betreffen, setzt jedoch voraus, dass das referenzierte Quellobjekt e während des Kopiervorgangs nicht durch andere Threads verändert wird. Frage Q-639cbb5cf8a64a0c (offen)

Zusammenspiel

Innerhalb der Spezialisierung ara::core::Result<void, E> ergänzen Überladungen für Rvalue-Referenzen (E&&) [SWS_CORE_00835] sowie zur In-Place-Konstruktion via Parameter-Pack [SWS_CORE_00836] diese Funktion; beide sind abweichend als not thread-safe deklariert. Korrespondierende Überladungen existieren zudem für den unvollständig spezialisierten Typ ara::core::Result ([SWS_CORE_00734], [SWS_CORE_00735], [SWS_CORE_00736]) und Referenz-Spezialisierungen ([SWS_CORE_00905], [SWS_CORE_00906], [SWS_CORE_00907]).

Verwendung

Die statische Funktion FromError erzeugt synchron eine neue Instanz von ara::core::Result<void, E> aus einem als Rvalue übergebenen Fehlerobjekt e [SWS_CORE_00835]. Die Funktion ist im Header ara/core/result.h definiert und gibt ein ara::core::Result zurück, welches den Fehlerwert enthält [SWS_CORE_00835].

Fehlerbehandlung und Nebenläufigkeit

Die Operation bietet bedingte Ausnahmesicherheit (conditionally exception safe): Sie garantiert Ausnahmefreiheit über noexcept, sofern der Fehlertyp E einen nicht-werfenden Move-Konstruktor besitzt (std::is_nothrow_move_constructible<E>::value) [SWS_CORE_00835]. Die Funktion ist als nicht threadsicher (not thread-safe) klassifiziert [SWS_CORE_00835]. Interpretation: Dies dürfte bedeuten, dass das zu verschiebende Rvalue-Objekt vor parallelen Zugriffen aus anderen Threads geschützt werden muss. Frage Q-be29e8c3a7412b7a (offen)

Zusammenspiel

Innerhalb der Spezialisierung ara::core::Result<void, E> stellt diese Überladung das Move-Gegenstück zur Lvalue-Kopierfunktion [SWS_CORE_00834] und zur In-Place-Konstruktion über Parameter-Packs [SWS_CORE_00836] dar. Vergleichbare Rvalue-Überladungen existieren im Modul core auch für Werttypen [SWS_CORE_00735] und Referenzen [SWS_CORE_00906], ergänzt um jeweilige Lvalue- ([SWS_CORE_00734], [SWS_CORE_00905]) und In-Place-Varianten ([SWS_CORE_00736], [SWS_CORE_00907]).

Die statische Template-Funktion FromError gemäß [SWS_CORE_00836] dient dazu, innerhalb der Spezialisierung ara::core::Result<void, E> ein fehlerbehaftetes Result-Objekt zu erzeugen, dessen Fehlerinstanz vom Typ E direkt an Ort und Stelle („in-place“) aus den übergebenen Argumenten args konstruiert wird. Die Funktion nimmt nur dann an der Überladungsauflösung teil, wenn std::is_constructible<E, Args&&...>::value wahr ist, der erste Typ des entpackten Parameter-Packs nicht E entspricht und auch keine Spezialisierung von Result ist [SWS_CORE_00836].

Hinsichtlich der Ausnahmesicherheit ist die Funktion als bedingt ausnahmesicher („conditionally exception safe“) spezifiziert: Sie ist mit noexcept(std::is_nothrow_constructible<E, Args...>::value) deklariert [SWS_CORE_00836]. Bezüglich der Nebenläufigkeit gilt der Aufruf als nicht threadsicher („not thread-safe“) [SWS_CORE_00836].

Im Zusammenspiel mit anderen Funktionen der Klasse ergänzt diese Methode die Überladungen zur Erzeugung aus bereits existierenden Lvalue- ([SWS_CORE_00834]) oder Rvalue-Fehlerobjekten ([SWS_CORE_00835]). Interpretation: Die SFINAE-Einschränkungen bezüglich E und Result dürften sicherstellen, dass bei Übergabe bereits erzeugter Fehler oder Result-Instanzen vorrangig die jeweiligen Kopier- bzw. Verschiebeoperatoren gewählt und Mehrdeutigkeiten vermieden werden. Frage Q-2796f954bcaececa (offen) Analoge In-Place-Fabrikfunktionen existieren für den generischen Typ Result ([SWS_CORE_00736]) sowie für Referenztypen in Result<T&, E> ([SWS_CORE_00907]).

Verwendung

Die statische Elementfunktion FromValue() dient der Erzeugung eines erfolgreichen ara::core::Result-Objekts für die Template-Spezialisierung ara::core::Result<void, E> [SWS_CORE_00831]. Da der Ergebnistyp void keine Nutzdaten transportiert, nimmt die Funktion keine Übergabeparameter entgegen. Der Aufruf erfolgt synchron und gibt ein Result zurück, das einen void-Wert repräsentiert [SWS_CORE_00831]. Die Deklaration erfolgt im Header ara/core/result.h [SWS_CORE_00831].

Fehlerbehandlung und Ausnahmesicherheit

Die Funktion ist mit der Spezifikation noexcept versehen und als vollständig ausnahmesicher (exception safe) klassifiziert [SWS_CORE_00831]. Da FromValue() definitionsgemäß eine erfolgreiche Operation darstellt, erzeugt sie keine Fehlerzustände und liefert keine Fehlercodes zurück. Spezifische Fehlermeldungen über DET oder DEM sind für diesen Aufruf nicht definiert.

Nebenläufigkeit

Gemäß Spezifikation ist die Funktion als threadsicher (thread-safe) eingestuft [SWS_CORE_00831]. Sie kann ohne zusätzliche Synchronisationsvorkehrungen parallel aus mehreren Threads heraus aufgerufen werden.

Zusammenspiel

Die parameterlose Signatur ist exklusiv für Result<void, E> vorgesehen [SWS_CORE_00831]. Sie grenzt sich von den werterzeugenden Überladungen ab:

• Für Werttypen Result<T, E> existieren Varianten für Lvalues [SWS_CORE_00731], Rvalues [SWS_CORE_00732] sowie In-Place-Konstruktionen [SWS_CORE_00733].
• Für Referenztypen Result<T&, E> bindet FromValue an eine Lvalue-Referenz [SWS_CORE_00904].

Die Elementfunktion Resolve der Template-Klasse ara::core::Result<void, E> dient der Fehlerbehandlung im Rahmen der generischen Programmierung [SWS_CORE_00867]. Wenn die Instanz von Result einen regulären Wert enthält, führt der Aufruf keine Operation aus [SWS_CORE_00867]. Enthält die Instanz stattdessen einen Fehler, wird das als Parameter übergebene Callable f aufgerufen [SWS_CORE_00867].

Das übergebene Callable f muss mit der Funktionssignatur void f(const E&) kompatibel sein, wobei E den Fehlertyp darstellt [SWS_CORE_00867]. Die Funktion Resolve selbst liefert keinen Rückgabewert (void) [SWS_CORE_00867]. Hinsichtlich der Ausführungssicherheit ist die Funktion als nicht exceptionsicher („not exception safe“) spezifiziert [SWS_CORE_00867]. Ihre Thread-Sicherheit ist konditional und hängt direkt von der Thread-Sicherheit des übergebenen Callables f ab [SWS_CORE_00867].

Im Gesamtsystem unterscheidet sich diese Spezialisierung von den regulären Resolve-Funktionen für Werttypen in ara::core::Result<T, E> [SWS_CORE_00767] sowie Referenztypen in ara::core::Result<T&, E> [SWS_CORE_00939], [SWS_CORE_00940]: Während jene Varianten den enthaltenen Wert oder das Ergebnis des Callable-Aufrufs zurückgeben, existiert die void-Überladung ohne Rückgabewert ausschließlich als generischer Baustein zur Vereinheitlichung von Schnittstellenaufrufen [SWS_CORE_00867].

Die Elementfunktion Swap vertauscht den Inhalt der aktuellen Instanz synchron mit der übergebenen Referenz other [SWS_CORE_00845]. Sie gehört zum Geltungsbereich der Spezialisierung ara::core::Result<void, E> aus der Header-Datei ara/core/result.h und besitzt keinen Rückgabewert [SWS_CORE_00845].

Hinsichtlich der Fehlerbehandlung ist die Operation als bedingt ausnahmesicher (conditionally exception safe) eingestuft [SWS_CORE_00845]. Die Zusicherung noexcept greift genau dann, wenn der Fehlertyp E sowohl nothrow-move-konstruierbar (std::is_nothrow_move_constructible<E>::value) als auch nothrow-move-zuweisbar (std::is_nothrow_move_assignable<E>::value) ist [SWS_CORE_00845]. Spezifische Fehlercodes oder Benachrichtigungen an DET oder DEM sind für diesen Aufruf nicht vorgesehen [SWS_CORE_00845].

Bezüglich der Nebenläufigkeit ist Swap ausdrücklich nicht threadsicher (not thread-safe) spezifiziert [SWS_CORE_00845]. Ein nebenläufiger Zugriff auf dieselben Instanzen ohne externe Synchronisation dürfte daher zu Datenrennen führen. Frage Q-a8d4f130648765df (offen)

Im Zusammenspiel innerhalb von ara::core bildet die Methode das Fundament für die freie Template-Funktion ara::core::swap, deren Noexcept-Bedingung direkt an die Elementfunktion gekoppelt ist [SWS_CORE_00796]. Vergleichbare Vertauschungsoperationen existieren für den generischen Typ ara::core::Result<T, E> [SWS_CORE_00745], die Referenzspezialisierung ara::core::Result<T&, E> [SWS_CORE_00917] sowie für Promise-Objekte [SWS_CORE_00352] [SWS_CORE_06352].

Die Elementfunktion ValueOr der Spezialisierung ara::core::Result<void, E> dient primär der Erleichterung generischer Programmiermuster und führt bei Ausführung keinerlei Operationen aus ([SWS_CORE_00861]). Über den Header ara/core/result.h bereitgestellt, nimmt die Methode synchron einen Parameter defaultValue vom Weiterleitungstyp U&& entgegen und liefert keinen Rückgabewert (void) ([SWS_CORE_00861]).

Hinsichtlich Nebenläufigkeit und Ausnahmeverhalten ist die Elementfunktion als threadsicher (thread-safe) spezifiziert und mit der Spezifizierersyntax noexcept deklariert, was eine vollständige Ausnahmesicherheit garantiert ([SWS_CORE_00861]). Da keine Prüfung des Fehlerzustands und keine Aktionen stattfinden, existieren weder Fehlercodes noch Meldungen an DET oder DEM.

Im Zusammenspiel mit den übrigen Ausprägungen von Result ergänzt diese Funktion die wertbasierten ([SWS_CORE_00761], [SWS_CORE_00762]) und referenzbasierten ([SWS_CORE_00933], [SWS_CORE_00934]) Überladungen von ValueOr. Während jene Funktionen bei gesetztem Wert diesen zurückgeben oder ansonsten den übergebenen Ersatzwert konvertiert ausliefern, stellt diese Variante ein neutrales Gegenstück für Operationen ohne Wertrückgabe dar ([SWS_CORE_00861]). Interpretation: Der übergebene Wert defaultValue dürfte in der Implementierung ungenutzt verworfen werden. Frage Q-6097af779219e859 (offen) Dies ermöglicht es Entwicklern, generische Template-Algorithmen ohne spezielle Verzweigungen für Result<void, E> zu verfassen.

Die Elementfunktion ValueOrThrow der Template-Spezialisierung ara::core::Result<void, E> dient der synchronen Überprüfung des Operationsergebnisses [SWS_CORE_00866]. Da der Werttyp void ist, besitzt die Funktion keine Parameter und liefert keinen Rückgabewert [SWS_CORE_00866]. Die Deklaration wird über den Header ara/core/result.h bereitgestellt [SWS_CORE_00866].

Im Erfolgsfall kehrt die Methode regulär zurück; liegt dagegen ein Fehlerzustand vor, wirft sie eine Ausnahme des mit dem enthaltenen Fehler verknüpften Ausnahmetyps (noexcept(false)) [SWS_CORE_00866]. In Bezug auf die Exception-Sicherheit ist die Operation als not exception safe spezifiziert [SWS_CORE_00866].

Für Aufrufkontext und Nebenläufigkeit gelten folgende Randbedingungen:

• Die Funktion ist als thread-safe eingestuft [SWS_CORE_00866].
• Falls C++-Exceptions in der Compiler-Toolchain deaktiviert sind, nimmt diese Funktion nicht an der Überladungsauflösung teil [SWS_CORE_00866].

Im Zusammenspiel mit dem Modul core ergänzt diese void-Spezialisierung die generischen Überladungen von ara::core::Result<T, E>, welche Referenzen auf enthaltene Werte zurückgeben ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]), sowie die Spezialisierungen für Referenztypen ara::core::Result<T&, E> ([SWS_CORE_00938], [SWS_CORE_00949]).

Die Template-Elementfunktion CheckError der Spezialisierung ara::core::Result<void, E> prüft synchron, ob die aktuelle Instanz einen bestimmten Fehler enthält [SWS_CORE_00865]. Hierzu wird das übergebene Argument error mittels static_cast in den Fehlertyp E umgewandelt und mit dem Rückgabewert des internen Fehlerzustands Error() verglichen [SWS_CORE_00865]. Der Aufruf erfolgt über den Header #include "ara/core/result.h" [SWS_CORE_00865].

Für die Verwendung und den Aufrufkontext gelten folgende Eigenschaften:

• Parameter und Rückgabewert: Der universelle Referenzparameter error vom Typ G&& nimmt den zu prüfenden Fehler entgegen [SWS_CORE_00865]. Die Funktion liefert true zurück, wenn die Instanz einen zu error äquivalenten Fehler enthält, andernfalls false [SWS_CORE_00865].
• Nebenläufigkeit und Ausnahmesicherheit: Die Operation ist als const noexcept deklariert, gilt als ausnahmesicher (exception safe) und ist uneingeschränkt threadsicher (thread-safe) aufrufbar [SWS_CORE_00865].

Im Zusammenspiel mit dem Modul core existieren analoge Überladungen von CheckError: Die primäre Template-Klasse ara::core::Result stellt dieselbe Signatur ebenfalls threadsicher und ausnahmesicher mit noexcept bereit [SWS_CORE_00765]. Demgegenüber besitzt die Referenz-Spezialisierung ara::core::Result<T&, E> zwar denselben Vergleichsmechanismus und ist threadsicher, jedoch explizit ohne noexcept als nicht ausnahmesicher (not exception safe) spezifiziert [SWS_CORE_00937].