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

Gebruik en aanroepcontext

De lidfunctie Bind van de specialisatie ara::core::Result<void, E> uit ara/core/result.h voert een vervolgberekening uit op een succesvolle instantie zonder resultaatwaarde [SWS_CORE_00870]. Als er een waarde aanwezig is, wordt de doorgegeven callable f synchroon en zonder parameters aangeroepen. De callable moet voldoen aan de interface Result<XXX, E> f() of XXX f(), waarbij XXX een voor Result toegestaan type moet zijn [SWS_CORE_00870]. Levert de callable een Result op, dan komt het retourtype overeen met decltype(f()); retourneert deze direct XXX, dan wordt het resultaat verpakt als Result<decltype(f()), E> [SWS_CORE_00870].

Foutafhandeling en gelijktijdigheid

Bevat de instantie geen waarde, dan wordt een nieuwe Result<XXX, E> geretourneerd waarin de oorspronkelijke fout wordt gekopieerd [SWS_CORE_00870]. Interpretatie: in dit geval blijft de uitvoering van de callable f vermoedelijk achterwege. Vraag Q-6288a7106d2730c3 (open) Wat betreft de uitvoeringsveiligheid geldt de functie als not exception safe [SWS_CORE_00870]. De thread-safety is voorwaardelijk (conditional) en hangt volledig af van de thread-safety van de doorgegeven callable f [SWS_CORE_00870].

Samenspel met verwante vereisten

In tegenstelling tot de primaire Result<T, E>-functies uit [SWS_CORE_00768] en [SWS_CORE_00941], waarbij de callable de waarde van de instantie via f(const T&) ontvangt, bindt de onderhavige overbelasting [SWS_CORE_00870] operaties aan void-resultaten en verwacht daarom een parameterloze callable.

De lidfunctie EmplaceError van de specialisatie ara::core::Result<void, E> construeert synchroon een nieuwe foutwaarde direct in-place binnen de bestaande instantie vanuit de doorgegeven argumenten args [SWS_CORE_00844]. De via het headerbestand ara/core/result.h beschikbaar gestelde templatefunctie heeft geen retourwaarde en initialiseert het foutobject van het type E direct ter plaatse [SWS_CORE_00844].

Met betrekking tot foutafhandeling en uitzonderingsveiligheid is de operatie geclassificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) [SWS_CORE_00844]. Via de specificator noexcept(std::is_nothrow_constructible<E, Args...>::value) wordt vrijheid van excepties gegarandeerd, mits het type E met de typen Args... zonder exceptie kan worden geconstrueerd [SWS_CORE_00844].

Met betrekking tot concurrency en randvoorwaarden is de lidfunctie gedefinieerd als niet thread-safe (not thread-safe) [SWS_CORE_00844]. Wanneer meerdere threads gelijktijdig toegang hebben tot dezelfde Result-instantie, is vermoedelijk een extern synchronisatiemechanisme vereist om ongecoördineerde toestandsveranderingen te voorkomen. Vraag Q-ffcb8ced860f6080 (open)

In de totale context van de module core correspondeert [SWS_CORE_00844] direct met de overige varianten van dezelfde functie: voor de primaire template ara::core::Result is het identieke gedrag gespecificeerd onder [SWS_CORE_00744], terwijl voor referentietypen ara::core::Result<T&, E> de eis [SWS_CORE_00916] dezelfde signatuur en semantiek voorschrijft.

Gebruik en aanroepcontext

De template-lidfunctie EmplaceValue behoort tot de module core en wordt via het headerbestand #include "ara/core/result.h" gedefinieerd voor de specialisatie ara::core::Result<void, E> [SWS_CORE_00843]. Het doel ervan is het direct aanmaken respectievelijk instellen van een nieuwe waarde in de bestaande instantie aan de hand van de doorgegeven argumenten args [SWS_CORE_00843]. De uitvoering geschiedt synchroon en levert geen retourwaarde (void) [SWS_CORE_00843]. Aangezien het waardetype van de specialisatie void is, brengt de aanroep de instantie in een succestoestand; als interpretatie dient het accepteren van args vermoedelijk primair voor generieke signatuurcompatibiliteit met de primaire templateklasse. Vraag Q-b53ca5908f2517fb (open)

Foutafhandeling en exception-veiligheid

De functie is gedeclareerd als noexcept en heeft de specificatie exception safe [SWS_CORE_00843]. Deze retourneert geen foutcodes en gooit geen excepties. Als het Result-object zich eerder in een fouttoestand bevond, wordt deze overschreven door het invoegen van de waarde.

Gelijktijdigheid en beperkingen

De operatie is aangemerkt als niet thread-safe (not thread-safe) [SWS_CORE_00843]. Bij potentieel gelijktijdige lees- of schrijftoegang tot dezelfde instantie van ara::core::Result is externe synchronisatie door de aanroeper dwingend vereist.

Samenspel met verwante specificaties

In vergelijking met de algemene implementatie van EmplaceValue voor ara::core::Result<T, E> in [SWS_CORE_00743], die slechts voorwaardelijk uitzonderingsveilig is en waarvan de noexcept-eigenschap afhangt van std::is_nothrow_constructible<T, Args...>::value, biedt de void-specialisatie conform [SWS_CORE_00843] een onbeperkte noexcept- en uitzonderingsveiligheidsgarantie.

De lidfunctie Err() const & van de klassespecialisatie ara::core::Result<void, E> maakt het synchroon opvragen van een mogelijk aanwezige fouttoestand mogelijk ([SWS_CORE_00868]). Ze wordt gedeclareerd via het headerbestand ara/core/result.h en vereist bij de aanroep geen overdrachtsparameters ([SWS_CORE_00868]). Als retourwaarde levert de functie een ara::core::Optional<E> op die de concrete foutwaarde bevat, mits het object een fout representeert ([SWS_CORE_00868]).

Met betrekking tot gelijktijdigheid en randvoorwaarden is de operatie expliciet gespecificeerd als thread-safe ([SWS_CORE_00868]). Wat betreft de uitzonderingsveiligheid geldt de methode als voorwaardelijk uitzonderingsveilig (conditionally exception safe) ([SWS_CORE_00868]). De noexcept-garantie geldt daarbij precies dan wanneer aan std::is_nothrow_constructible<Optional<E>, const E&>::value is voldaan ([SWS_CORE_00868]).

In het geheel van interfaces vult de rvalue-overbelasting Err() && ([SWS_CORE_00869]) deze functie aan binnen ara::core::Result<void, E>. Vergelijkbare paren van lvalue- en rvalue-overbelastingen staan ook ter beschikking voor de primaire sjabloon ara::core::Result<T, E> ([SWS_CORE_00772], [SWS_CORE_00773]) en voor de referentiespecialisatie ara::core::Result<T&, E> ([SWS_CORE_00931], [SWS_CORE_00932]).

De lidfunctie Err() && van de specialisatie ara::core::Result< void, E > extraheert een eventueel aanwezige fout en retourneert deze als ara::core::Optional< E > [SWS_CORE_00869]. Ze is ingevoegd via het headerbestand ara/core/result.h [SWS_CORE_00869].

Wat betreft gebruik en semantiek gelden de volgende eigenschappen:

• Aanroepcontext en parameters: de functie accepteert geen parameters en bindt als rvalue-gekwalificeerde methode uitsluitend aan rvalue-instanties van ara::core::Result< void, E > [SWS_CORE_00869]. Interpretatie: door de rvalue-semantiek (&&) wordt het foutobject bij de aanroep vermoedelijk verplaatst naar de geretourneerde Optional. Vraag Q-b5a0098f77686ca6 (open)
• Retourwaarde: de resulterende ara::core::Optional< E > bevat de foutwaarde, mits een dergelijke waarde in het object aanwezig is [SWS_CORE_00869].
• Uitzonderingsveiligheid en concurrency: De operatie is geclassificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) en werpt geen uitzonderingen op als aan std::is_nothrow_constructible< Optional< E >, E && >::value is voldaan [SWS_CORE_00869]. Bovendien is de functie gespecificeerd als thread-safe (thread-safe) [SWS_CORE_00869].

In het samenspel van de interfaces vult deze rvalue-variant de overeenkomstige lvalue-overload Err() const & van dezelfde specialisatie aan [SWS_CORE_00868]. Analoge paren van lvalue- en rvalue-methoden bestaan voor de primaire template ara::core::Result [SWS_CORE_00772], [SWS_CORE_00773] en voor de referentiespecialisatie ara::core::Result< T &, E > [SWS_CORE_00931], [SWS_CORE_00932].

De sjabloonlidfunctie ErrorOr van de specialisatie ara::core::Result<void, E> dient voor het synchroon opvragen van de aanwezige fout of een alternatieve standaardfout volgens [SWS_CORE_00863]. Als de instantie reeds een foutwaarde van het type E bevat, wordt deze ongewijzigd geretourneerd; anders wordt de doorgegeven parameter defaultError door middel van static_cast geconverteerd naar het fouttype E en geretourneerd [SWS_CORE_00863].

Wat betreft foutafhandeling en gelijktijdigheid gelden de volgende eigenschappen:

• Uitzonderingsveiligheid: de aanroep is voorwaardelijk uitzonderingsveilig (conditionally exception safe) en gedeclareerd als noexcept, mits zowel de kopieerconstructie van E als de constructie van E vanuit het universele referentietype G&& niet werpend zijn (std::is_nothrow_copy_constructible<E>::value && std::is_nothrow_constructible<E, G&&>::value) [SWS_CORE_00863].
• Thread-safety: de operatie is gespecificeerd als thread-safe (thread-safe) [SWS_CORE_00863]. Aangezien het een constante lvalue-referentie-overbelasting (const &) betreft, zijn gelijktijdige leestoegangen op dezelfde instantie vermoedelijk veilig. Vraag Q-f95402c2e79ef590 (open)
• Header: de functie wordt beschikbaar gesteld via het headerbestand #include "ara/core/result.h" [SWS_CORE_00863].

In het samenspel binnen ara::core::Result vormt [SWS_CORE_00863] de lvalue-constante tegenhanger van de rvalue-overbelasting [SWS_CORE_00864] voor void-resultaten, waarbij de fout via std::move wordt overgedragen. Equivalente overbelastingen bestaan voor de primaire klassesjabloon Result<T, E> via [SWS_CORE_00763] en [SWS_CORE_00764], evenals voor referentietypen Result<T &, E> via [SWS_CORE_00935] en [SWS_CORE_00936].

Gebruik en semantiek

De lidfunctie ErrorOr van de specialisatie ara::core::Result<void, E> dient voor het synchroon uitlezen van een fout uit een rvalue-instantie ([SWS_CORE_00864]). Als de methode wordt aangeroepen en het Result-object een fout bevat, wordt deze door middel van std::move verplaatst naar de retourwaarde van het type E. Ligt daarentegen een succesvol resultaat voor, dan wordt het doorgegeven argument defaultError via static_cast geconverteerd naar E en geretourneerd ([SWS_CORE_00864]).

Foutafhandeling en exception-veiligheid

De functie genereert zelf geen klassieke AUTOSAR-foutmeldingen zoals DET of DEM. Wat betreft de uitzonderingsafhandeling is ErrorOr voorwaardelijk uitzonderingsveilig (conditionally exception safe). Ze is beveiligd via een noexcept-expressie, mits zowel het fouttype E zonder uitzonderingen kan worden verplaatst (std::is_nothrow_move_constructible<E>::value) als E uitzonderingsvrij kan worden geconstrueerd vanuit het universele referentietype G&& van de standaardfout ([SWS_CORE_00864]).

Gelijktijdigheid en wisselwerking

De methode is gespecificeerd als thread-safe ([SWS_CORE_00864]). Door de rvalue-ref-qualifier && vereist de aanroep dat het Result-object als rvalue wordt doorgegeven.

In de module core staat deze rvalue-variant in verband met verdere manifestaties:

• Voor ara::core::Result<void, E> bestaat als lvalue-tegenhanger de const &-overbelasting [SWS_CORE_00863], die de fout kopieert in plaats van verplaatst.
• Voor waarde- en referentieresultaten bieden de specialisaties ara::core::Result<T, E> ([SWS_CORE_00763], [SWS_CORE_00764]) en ara::core::Result<T&, E> ([SWS_CORE_00935], [SWS_CORE_00936]) dezelfde duale signatuurstructuur voor kopieer- en move-semantiek.

Gebruik

De statische functie FromError maakt deel uit van de template-specialisatie ara::core::Result<void, E> en wordt geïncludeerd via het headerbestand ara/core/result.h [SWS_CORE_00834]. Ze dient als synchrone factory-methode om op basis van een reeds bestaand foutobject een nieuwe Result te construeren [SWS_CORE_00834].

• Parameters: De invoerparameter e accepteert de fout als constante lvalue-referentie (const E &) [SWS_CORE_00834].
• Retourwaarde: Retourneert een instantie van Result die de overgedragen fout e bevat [SWS_CORE_00834].

Foutafhandeling en uitzonderingsveiligheid

De specificatie definieert geen specifieke foutcodes en voorziet niet in meldingen aan DET of DEM [SWS_CORE_00834]. De functie is voorwaardelijk uitzonderingsveilig (conditionally exception safe): ze is precies dan als noexcept gegarandeerd wanneer het fouttype E zonder werpen van excepties kopieerbaar is (std::is_nothrow_copy_constructible<E>::value) [SWS_CORE_00834].

Concurrency

De aanroep is geclassificeerd als thread-safe [SWS_CORE_00834]. Interpretatie: de thread-safety heeft vermoedelijk betrekking op het interne verloop van de objectcreatie, maar veronderstelt dat het gereferentieerde bronobject e tijdens het kopiëren niet door andere threads wordt gewijzigd. Vraag Q-639cbb5cf8a64a0c (open)

Samenspel

Binnen de specialisatie ara::core::Result<void, E> vullen overloads voor rvalue-referenties (E&&) [SWS_CORE_00835] evenals voor in-place constructie via parameter pack [SWS_CORE_00836] deze functie aan; beide zijn afwijkend als not thread-safe gedeclareerd. Corresponderende overloads bestaan bovendien voor het onvolledig gespecialiseerde type ara::core::Result ([SWS_CORE_00734], [SWS_CORE_00735], [SWS_CORE_00736]) en referentiespecialisaties ([SWS_CORE_00905], [SWS_CORE_00906], [SWS_CORE_00907]).

Gebruik

De statische functie FromError genereert synchroon een nieuwe instantie van ara::core::Result<void, E> uit een als rvalue overgedragen foutobject e [SWS_CORE_00835]. De functie is gedefinieerd in de header ara/core/result.h en retourneert een ara::core::Result dat de foutwaarde bevat [SWS_CORE_00835].

Foutafhandeling en gelijktijdigheid

De operatie biedt voorwaardelijke uitzonderingsveiligheid (conditionally exception safe): ze garandeert uitzonderingsvrijheid via noexcept, mits het fouttype E een niet-werpende move-constructor heeft (std::is_nothrow_move_constructible<E>::value) [SWS_CORE_00835]. De functie is geclassificeerd als niet thread-safe (not thread-safe) [SWS_CORE_00835]. Interpretatie: dit lijkt te betekenen dat het te verplaatsen rvalue-object beschermd moet worden tegen parallelle toegang vanuit andere threads. Vraag Q-be29e8c3a7412b7a (open)

Samenspel

Binnen de specialisatie ara::core::Result<void, E> vormt deze overbelasting de move-tegenhanger van de lvalue-kopieerfunctie [SWS_CORE_00834] en van de in-place-constructie via parameter packs [SWS_CORE_00836]. Vergelijkbare rvalue-overbelastingen bestaan in de module core ook voor waardetypen [SWS_CORE_00735] en referenties [SWS_CORE_00906], aangevuld met respectievelijke lvalue- ([SWS_CORE_00734], [SWS_CORE_00905]) en in-place-varianten ([SWS_CORE_00736], [SWS_CORE_00907]).

De statische templatefunctie FromError conform [SWS_CORE_00836] dient ertoe om binnen de specialisatie ara::core::Result<void, E> een result-object met fout te creëren, waarvan de foutinstantie van het type E direct ter plekke („in-place”) wordt geconstrueerd uit de meegegeven argumenten args. De functie neemt alleen deel aan de overbelastingsresolutie wanneer std::is_constructible<E, Args&&...>::value waar is, het eerste type van het uitgepakte parameter pack niet overeenkomt met E en ook geen specialisatie van Result is [SWS_CORE_00836].

Wat betreft uitzonderingsveiligheid is de functie gespecificeerd als voorwaardelijk uitzonderingsveilig („conditionally exception safe”): zij is gedeclareerd met noexcept(std::is_nothrow_constructible<E, Args...>::value) [SWS_CORE_00836]. Met betrekking tot gelijktijdigheid geldt de aanroep als niet-thread-safe („not thread-safe”) [SWS_CORE_00836].

In samenspel met andere functies van de klasse vult deze methode de overbelastingen aan voor creatie uit reeds bestaande lvalue- ([SWS_CORE_00834]) of rvalue-foutobjecten ([SWS_CORE_00835]). Interpretatie: De SFINAE-beperkingen met betrekking tot E en Result zijn er vermoedelijk voor bedoeld om te waarborgen dat bij doorgave van reeds gecreëerde fout- of result-instanties bij voorrang de respectievelijke kopieer- respectievelijk verplaatsingsoperatoren worden gekozen en dubbelzinnigheden worden vermeden. Vraag Q-2796f954bcaececa (open) Analoge in-place-fabrieksfuncties bestaan voor het generieke type Result ([SWS_CORE_00736]) en voor referentietypen in Result<T&, E> ([SWS_CORE_00907]).

Gebruik

De statische lidfunctie FromValue() dient voor het aanmaken van een succesvol ara::core::Result-object voor de templatespecialisatie ara::core::Result<void, E> [SWS_CORE_00831]. Aangezien het resultaattype void geen gebruikersdata transporteert, accepteert de functie geen invoerparameters. De aanroep geschiedt synchroon en retourneert een Result die een void-waarde representeert [SWS_CORE_00831]. De declaratie vindt plaats in de header ara/core/result.h [SWS_CORE_00831].

Foutafhandeling en uitzonderingsveiligheid

De functie is voorzien van de specificatie noexcept en geclassificeerd als volledig uitzonderingsveilig (exception safe) [SWS_CORE_00831]. Aangezien FromValue() per definitie een succesvolle operatie representeert, genereert deze geen fouttoestanden en levert deze geen foutcodes op. Specifieke foutmeldingen via DET of DEM zijn voor deze aanroep niet gedefinieerd.

Concurrency

Volgens de specificatie is de functie geclassificeerd als thread-safe (thread-safe) [SWS_CORE_00831]. Deze kan zonder aanvullende synchronisatiemaatregelen parallel vanuit meerdere threads worden aangeroepen.

Samenspel

De parameterloze signatuur is exclusief bedoeld voor Result<void, E> [SWS_CORE_00831]. Deze onderscheidt zich van de waardegenererende overbelastingen:

• Voor waardetypen Result<T, E> bestaan varianten voor lvalues [SWS_CORE_00731], rvalues [SWS_CORE_00732] evenals in-place-constructies [SWS_CORE_00733].
• Voor referentietypen Result<T&, E> bindt FromValue aan een lvalue-referentie [SWS_CORE_00904].

De lidfunctie Resolve van de templateklasse ara::core::Result<void, E> dient voor de foutafhandeling in het kader van generiek programmeren [SWS_CORE_00867]. Wanneer de instantie van Result een reguliere waarde bevat, voert de aanroep geen operatie uit [SWS_CORE_00867]. Bevat de instantie in plaats daarvan een fout, dan wordt de als parameter doorgegeven callable f aangeroepen [SWS_CORE_00867].

De doorgegeven callable f moet compatibel zijn met de functiesignatuur void f(const E&), waarbij E het fouttype representeert [SWS_CORE_00867]. De functie Resolve zelf levert geen retourwaarde op (void) [SWS_CORE_00867]. Wat betreft de uitvoeringsveiligheid is de functie gespecificeerd als niet-exceptieveilig („not exception safe”) [SWS_CORE_00867]. De thread-safety ervan is voorwaardelijk en hangt direct af van de thread-safety van de doorgegeven callable f [SWS_CORE_00867].

In het totale systeem verschilt deze specialisatie van de reguliere Resolve-functies voor waardetypen in ara::core::Result<T, E> [SWS_CORE_00767] evenals referentietypen in ara::core::Result<T&, E> [SWS_CORE_00939], [SWS_CORE_00940]: terwijl die varianten de aanwezige waarde of het resultaat van de callable-aanroep retourneren, bestaat de void-overbelasting zonder retourwaarde uitsluitend als generieke bouwsteen ter uniformering van interface-aanroepen [SWS_CORE_00867].

De lidfunctie Swap verwisselt de inhoud van de huidige instantie synchroon met de doorgegeven referentie other [SWS_CORE_00845]. Deze behoort tot het bereik van de specialisatie ara::core::Result<void, E> uit het headerbestand ara/core/result.h en heeft geen retourwaarde [SWS_CORE_00845].

Met betrekking tot de foutafhandeling is de operatie geclassificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) [SWS_CORE_00845]. De garantie noexcept geldt dan en slechts dan als het fouttype E zowel nothrow-move-construeerbaar (std::is_nothrow_move_constructible<E>::value) als nothrow-move-toewijsbaar (std::is_nothrow_move_assignable<E>::value) is [SWS_CORE_00845]. Specifieke foutcodes of meldingen aan DET of DEM zijn voor deze aanroep niet voorzien [SWS_CORE_00845].

Wat betreft concurrency is Swap uitdrukkelijk gespecificeerd als niet thread-safe (not thread-safe) [SWS_CORE_00845]. Gelijktijdige toegang tot dezelfde instanties zonder externe synchronisatie leidt daarom vermoedelijk tot datastrijd (data races). Vraag Q-a8d4f130648765df (open)

In het samenspel binnen ara::core vormt de methode het fundament voor de vrije templatefunctie ara::core::swap, waarvan de noexcept-voorwaarde direct gekoppeld is aan de lidfunctie [SWS_CORE_00796]. Vergelijkbare verwisseloperaties bestaan voor het generieke type ara::core::Result<T, E> [SWS_CORE_00745], de referentiespecialisatie ara::core::Result<T&, E> [SWS_CORE_00917] evenals voor Promise-objecten [SWS_CORE_00352] [SWS_CORE_06352].

De lidfunctie ValueOr van de specialisatie ara::core::Result<void, E> dient primair ter vergemakkelijking van generieke programmeerpatronen en voert bij uitvoering generlei operaties uit ([SWS_CORE_00861]). Aangeboden via de header ara/core/result.h, accepteert de methode synchroon een parameter defaultValue van het doorstuurtype U&& en levert geen retourwaarde (void) ([SWS_CORE_00861]).

Met betrekking tot concurrency en uitzonderingsgedrag is de lidfunctie gespecificeerd als thread-safe (thread-safe) en gedeclareerd met de specificator-syntaxis noexcept, wat een volledige uitzonderingsveiligheid garandeert ([SWS_CORE_00861]). Aangezien er geen controle van de fouttoestand en geen acties plaatsvinden, bestaan er noch foutcodes noch meldingen aan DET of DEM.

In het samenspel met de overige vormen van Result vult deze functie de op waarden gebaseerde ([SWS_CORE_00761], [SWS_CORE_00762]) en op referenties gebaseerde ([SWS_CORE_00933], [SWS_CORE_00934]) overbelastingen van ValueOr aan. Terwijl die functies bij een ingestelde waarde deze retourneren of anders de doorgegeven vervangende waarde geconverteerd opleveren, vormt deze variant een neutraal tegenhanger voor operaties zonder waarderetour ([SWS_CORE_00861]). Interpretatie: de doorgegeven waarde defaultValue wordt in de implementatie vermoedelijk ongebruikt verworpen. Vraag Q-6097af779219e859 (open) Dit stelt ontwikkelaars in staat om generieke template-algoritmen te schrijven zonder speciale vertakkingen voor Result<void, E>.

De lidfunctie ValueOrThrow van de template-specialisatie ara::core::Result<void, E> dient voor de synchrone controle van het operatieresultaat [SWS_CORE_00866]. Omdat het waardetype void is, heeft de functie geen parameters en levert ze geen retourwaarde op [SWS_CORE_00866]. De declaratie wordt geleverd via de header ara/core/result.h [SWS_CORE_00866].

In geval van succes keert de methode regulier terug; is er daarentegen sprake van een fouttoestand, dan werpt ze een exceptie op van het exceptietype dat aan de ingesloten fout is gekoppeld (noexcept(false)) [SWS_CORE_00866]. Wat betreft de uitzonderingsveiligheid is de operatie gespecificeerd als not exception safe [SWS_CORE_00866].

Voor de aanroepcontext en gelijktijdigheid gelden de volgende randvoorwaarden:

• De functie is geclassificeerd als thread-safe [SWS_CORE_00866].
• Indien C++-exceptions in de compiler-toolchain zijn uitgeschakeld, neemt deze functie niet deel aan de overbelastingsresolutie [SWS_CORE_00866].

In samenspel met de module core vormt deze void-specialisatie een aanvulling op de generieke overbelastingen van ara::core::Result<T, E>, die referenties naar ingesloten waarden retourneren ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]), evenals op de specialisaties voor referentietypen ara::core::Result<T&, E> ([SWS_CORE_00938], [SWS_CORE_00949]).

De template-lidfunctie CheckError van de specialisatie ara::core::Result<void, E> controleert synchroon of de huidige instantie een bepaalde fout bevat [SWS_CORE_00865]. Hiervoor wordt het doorgegeven argument error door middel van static_cast omgezet in het fouttype E en vergeleken met de retourwaarde van de interne fouttoestand Error() [SWS_CORE_00865]. De aanroep geschiedt via de header #include "ara/core/result.h" [SWS_CORE_00865].

Voor het gebruik en de aanroepcontext gelden de volgende eigenschappen:

• Parameters en retourwaarde: De universele referentieparameter error van het type G&& accepteert de te controleren fout [SWS_CORE_00865]. De functie retourneert true als de instantie een fout bevat die equivalent is aan error, anders false [SWS_CORE_00865].
• Concurrency en uitzonderingsveiligheid: De operatie is gedeclareerd als const noexcept, geldt als uitzonderingsveilig (exception safe) en kan onbeperkt thread-safe (thread-safe) worden aangeroepen [SWS_CORE_00865].

In het samenspel met de module core bestaan analoge overbelastingen van CheckError: de primaire templateklasse ara::core::Result stelt dezelfde signatuur eveneens thread-safe en uitzonderingsveilig met noexcept beschikbaar [SWS_CORE_00765]. Daarentegen beschikt de referentiespecialisatie ara::core::Result<T&, E> weliswaar over hetzelfde vergelijkingsmechanisme en is deze thread-safe, maar expliciet zonder noexcept als niet-uitzonderingsveilig (not exception safe) gespecificeerd [SWS_CORE_00937].