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

Utilisation et contexte d'appel

La fonction membre Bind de la spécialisation ara::core::Result<void, E> issue de ara/core/result.h exécute un calcul consécutif sur une instance de succès sans valeur de résultat [SWS_CORE_00870]. Si une valeur est présente, le callable transmis f est appelé de manière synchrone et sans paramètre. Le callable doit satisfaire soit l'interface Result<XXX, E> f() soit XXX f(), où XXX doit être un type admissible pour Result [SWS_CORE_00870]. Si le callable fournit un Result, le type de retour correspond à decltype(f()) ; s'il renvoie directement XXX, le résultat est encapsulé sous forme de Result<decltype(f()), E> [SWS_CORE_00870].

Gestion des erreurs et concurrence

Si l'instance ne contient aucune valeur, un nouveau Result<XXX, E> est renvoyé, dans lequel l'erreur d'origine est copiée [SWS_CORE_00870]. Interprétation : dans ce cas, l'exécution du callable f ne devrait pas avoir lieu. Question Q-6288a7106d2730c3 (ouverte) Concernant la sécurité d'exécution, la fonction est considérée comme not exception safe [SWS_CORE_00870]. La sécurité vis-à-vis des threads est conditionnelle (conditional) et dépend entièrement de la sécurité vis-à-vis des threads du callable transmis f [SWS_CORE_00870].

Interaction avec des exigences connexes

Contrairement aux fonctions primaires Result<T, E> issues de [SWS_CORE_00768] et [SWS_CORE_00941], pour lesquelles le callable reçoit la valeur de l'instance par f(const T&), la présente surcharge [SWS_CORE_00870] lie les opérations à des résultats void et attend par conséquent un callable sans paramètre.

La fonction membre EmplaceError de la spécialisation ara::core::Result<void, E> construit de manière synchrone une nouvelle valeur d'erreur directement in-place au sein de l'instance existante à partir des arguments transmis args [SWS_CORE_00844]. Mise à disposition via le fichier d'en-tête ara/core/result.h, la fonction modèle ne possède aucune valeur de retour et initialise l'objet d'erreur de type E directement sur place [SWS_CORE_00844].

En ce qui concerne le traitement des erreurs et la sécurité vis-à-vis des exceptions, l'opération est classée comme conditionnellement sûre du point de vue des exceptions (conditionally exception safe) [SWS_CORE_00844]. L'absence d'exception est garantie via le spécificateur noexcept(std::is_nothrow_constructible<E, Args...>::value), pour autant que le type E puisse être construit avec les types Args... sans exception [SWS_CORE_00844].

En matière de concurrence et de contraintes, la fonction membre est définie comme non sûre pour les threads (not thread-safe) [SWS_CORE_00844]. Si plusieurs threads accèdent de manière concurrente à la même instance Result, un mécanisme de synchronisation externe est vraisemblablement nécessaire afin d'éviter toute modification d'état non coordonnée. Question Q-ffcb8ced860f6080 (ouverte)

Dans le contexte global du module core, [SWS_CORE_00844] correspond directement aux autres variantes de la même fonction : pour le modèle primaire ara::core::Result, le comportement identique est spécifié sous [SWS_CORE_00744], tandis que pour les types référence ara::core::Result<T&, E>, l'exigence [SWS_CORE_00916] prescrit la même signature et la même sémantique.

Utilisation et contexte d'appel

La fonction membre modèle EmplaceValue appartient au module core et est définie via le fichier d'en-tête #include "ara/core/result.h" pour la spécialisation ara::core::Result<void, E> [SWS_CORE_00843]. Son but est la création directe ou la définition d'une nouvelle valeur dans l'instance existante à partir des arguments transmis args [SWS_CORE_00843]. L'exécution s'effectue de manière synchrone et ne fournit aucune valeur de retour (void) [SWS_CORE_00843]. Étant donné que le type valeur de la spécialisation est void, l'appel fait passer l'instance dans un état de succès ; selon l'interprétation, la réception de args devrait principalement servir à la compatibilité générique de signature avec la classe modèle primaire. Question Q-b53ca5908f2517fb (ouverte)

Gestion des erreurs et sécurité vis-à-vis des exceptions

La fonction est déclarée comme noexcept et possède la spécification exception safe [SWS_CORE_00843]. Elle ne renvoie aucun code d'erreur et ne lève aucune exception. Si l'objet Result se trouvait auparavant dans un état d'erreur, celui-ci est écrasé par l'insertion de la valeur.

Concurrence et restrictions

L'opération est désignée comme non sûre pour les threads (not thread-safe) [SWS_CORE_00843]. En cas d'accès potentiellement concurrents en lecture ou en écriture à la même instance de ara::core::Result, une synchronisation externe par l'appelant est impérativement requise.

Interaction avec les spécifications apparentées

Par rapport à l'implémentation générale de EmplaceValue pour ara::core::Result<T, E> dans [SWS_CORE_00743], qui n'est que conditionnellement sûre du point de vue des exceptions et dont la propriété noexcept dépend de std::is_nothrow_constructible<T, Args...>::value, la spécialisation void selon [SWS_CORE_00843] offre une garantie de noexcept et de sécurité vis-à-vis des exceptions sans restriction.

La fonction membre Err() const & de la spécialisation de classe ara::core::Result<void, E> permet l'interrogation synchrone d'un état d'erreur éventuellement contenu ([SWS_CORE_00868]). Elle est déclarée via le fichier d'en-tête ara/core/result.h et ne requiert aucun paramètre d'entrée lors de l'appel ([SWS_CORE_00868]). Comme valeur de retour, la fonction fournit un ara::core::Optional<E> qui contient la valeur d'erreur concrète si l'objet représente une erreur ([SWS_CORE_00868]).

En ce qui concerne la concurrence et les conditions aux limites, l'opération est explicitement spécifiée comme thread-safe ([SWS_CORE_00868]). Pour ce qui est de la sécurité vis-à-vis des exceptions, la méthode est considérée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) ([SWS_CORE_00868]). La garantie noexcept s'applique alors précisément lorsque std::is_nothrow_constructible<Optional<E>, const E&>::value est satisfaite ([SWS_CORE_00868]).

Dans l'ensemble des interfaces, la surcharge rvalue Err() && ([SWS_CORE_00869]) complète cette fonction au sein de ara::core::Result<void, E>. Des paires comparables de surcharges lvalue et rvalue sont également disponibles pour le modèle primaire ara::core::Result<T, E> ([SWS_CORE_00772], [SWS_CORE_00773]) ainsi que pour la spécialisation de référence ara::core::Result<T&, E> ([SWS_CORE_00931], [SWS_CORE_00932]).

La fonction membre Err() && de la spécialisation ara::core::Result< void, E > extrait une erreur éventuellement présente et la renvoie sous forme de ara::core::Optional< E > [SWS_CORE_00869]. Elle est incluse via le fichier d'en-tête ara/core/result.h [SWS_CORE_00869].

Concernant l'utilisation et la sémantique, les propriétés suivantes s'appliquent :

• Contexte d'appel et paramètres : la fonction ne prend aucun paramètre et se lie, en tant que méthode qualifiée rvalue, exclusivement aux instances rvalue de ara::core::Result< void, E > [SWS_CORE_00869]. Interprétation : en raison de la sémantique rvalue (&&), l'objet d'erreur devrait être déplacé lors de l'appel dans l'Optional renvoyé. Question Q-b5a0098f77686ca6 (ouverte)
• Valeur de retour : le ara::core::Optional< E > résultant contient la valeur d'erreur si une telle valeur est présente dans l'objet [SWS_CORE_00869].
• Sécurité vis-à-vis des exceptions et concurrence : l'opération est classée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) et ne lève aucune exception si std::is_nothrow_constructible< Optional< E >, E && >::value est satisfait [SWS_CORE_00869]. De plus, la fonction est spécifiée comme sûre pour les threads (thread-safe) [SWS_CORE_00869].

Dans l'interaction des interfaces, cette variante rvalue complète la surcharge lvalue correspondante Err() const & de la même spécialisation [SWS_CORE_00868]. Des paires analogues de méthodes lvalue et rvalue existent pour le modèle primaire ara::core::Result [SWS_CORE_00772], [SWS_CORE_00773] ainsi que pour la spécialisation de référence ara::core::Result< T &, E > [SWS_CORE_00931], [SWS_CORE_00932].

La fonction membre d'archétype ErrorOr de la spécialisation ara::core::Result<void, E> sert à la récupération synchrone de l'erreur contenue ou d'une erreur par défaut alternative conformément à [SWS_CORE_00863]. Si l'instance contient déjà une valeur d'erreur de type E, celle-ci est renvoyée inchangée ; dans le cas contraire, le paramètre transmis defaultError est converti au moyen de static_cast dans le type d'erreur E et renvoyé [SWS_CORE_00863].

Concernant le traitement des erreurs et la concurrence, les propriétés suivantes s'appliquent :

• Sécurité vis-à-vis des exceptions : l'appel est conditionnellement sûr vis-à-vis des exceptions (conditionally exception safe) et déclaré comme noexcept, pour autant que la construction par copie de E ainsi que la construction de E à partir du type de référence universelle G&& ne lèvent pas d'exception (std::is_nothrow_copy_constructible<E>::value && std::is_nothrow_constructible<E, G&&>::value) [SWS_CORE_00863].
• Sécurité des threads : l'opération est spécifiée comme sûre pour les threads (thread-safe) [SWS_CORE_00863]. S'agissant d'une surcharge de référence lvalue constante (const &), les accès simultanés en lecture à la même instance devraient être sûrs. Question Q-f95402c2e79ef590 (ouverte)
• En-tête : la fonction est mise à disposition via le fichier d'en-tête #include "ara/core/result.h" [SWS_CORE_00863].

Au sein de l'interaction dans ara::core::Result, [SWS_CORE_00863] constitue le pendant lvalue constant de la surcharge rvalue [SWS_CORE_00864] pour les résultats void, dans laquelle l'erreur est transmise via std::move. Des surcharges équivalentes existent pour le modèle de classe primaire Result<T, E> via [SWS_CORE_00763] et [SWS_CORE_00764] ainsi que pour les types de référence Result<T &, E> via [SWS_CORE_00935] et [SWS_CORE_00936].

Utilisation et sémantique

La fonction membre ErrorOr de la spécialisation ara::core::Result<void, E> sert à la lecture synchrone d'une erreur à partir d'une instance rvalue ([SWS_CORE_00864]). Si la méthode est appelée et que l'objet Result contient une erreur, celle-ci est déplacée au moyen de std::move dans la valeur de retour de type E. Si un résultat réussi est en revanche présent, l'argument transmis defaultError est converti via static_cast vers E et renvoyé ([SWS_CORE_00864]).

Gestion des erreurs et sécurité vis-à-vis des exceptions

La fonction ne déclenche elle-même aucun message d'erreur AUTOSAR classique tel que DET ou DEM. En ce qui concerne le traitement des exceptions, ErrorOr est conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe). Elle est sécurisée par une expression noexcept, pour autant que le type d'erreur E soit déplaçable sans exception (std::is_nothrow_move_constructible<E>::value) et que E puisse être construit sans exception à partir du type de référence universelle G&& de l'erreur par défaut ([SWS_CORE_00864]).

Concurrence et interaction

La méthode est spécifiée comme thread-safe ([SWS_CORE_00864]). En raison du qualificateur de référence rvalue &&, l'appel suppose que l'objet Result soit transmis comme une rvalue.

Dans le module core, cette variante rvalue s'inscrit en conjonction avec d'autres déclinaisons :

• Pour ara::core::Result<void, E>, il existe comme pendant lvalue la surcharge const & [SWS_CORE_00863], qui copie l'erreur au lieu de la déplacer.
• Pour les résultats par valeur et par référence, les spécialisations ara::core::Result<T, E> ([SWS_CORE_00763], [SWS_CORE_00764]) ainsi que ara::core::Result<T&, E> ([SWS_CORE_00935], [SWS_CORE_00936]) offrent la même structure de signature duale pour la sémantique de copie et de déplacement.

Utilisation

La fonction statique FromError fait partie de la spécialisation de modèle ara::core::Result<void, E> et est incluse via le fichier d'en-tête ara/core/result.h [SWS_CORE_00834]. Elle sert de méthode fabrique synchrone afin de construire un nouveau Result à partir d'un objet d'erreur déjà existant [SWS_CORE_00834].

• Paramètre : Le paramètre d'entrée e reçoit l'erreur sous la forme d'une référence lvalue constante (const E &) [SWS_CORE_00834].
• Valeur de retour : Renvoie une instance de Result contenant l'erreur transmise e [SWS_CORE_00834].

Gestion des erreurs et sécurité vis-à-vis des exceptions

La spécification ne définit aucun code d'erreur spécifique et ne prévoit aucune notification destinée au DET ou au DEM [SWS_CORE_00834]. La fonction est conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) : elle est garantie comme noexcept si et seulement si le type d'erreur E est copiable sans levée d'exception (std::is_nothrow_copy_constructible<E>::value) [SWS_CORE_00834].

concurrence

L'appel est classé comme thread-safe [SWS_CORE_00834]. Interprétation : la sécurité des threads devrait concerner le déroulement interne de la création de l'objet, mais suppose toutefois que l'objet source référencé e ne soit pas modifié par d'autres threads pendant l'opération de copie. Question Q-639cbb5cf8a64a0c (ouverte)

Interaction

Au sein de la spécialisation ara::core::Result<void, E>, des surcharges pour les références rvalue (E&&) [SWS_CORE_00835] ainsi que pour la construction sur place (in-place) via un pack de paramètres [SWS_CORE_00836] complètent cette fonction ; les deux sont déclarées, à titre dérogatoire, comme not thread-safe. Des surcharges correspondantes existent en outre pour le type incomplètement spécialisé ara::core::Result ([SWS_CORE_00734], [SWS_CORE_00735], [SWS_CORE_00736]) et les spécialisations de références ([SWS_CORE_00905], [SWS_CORE_00906], [SWS_CORE_00907]).

Utilisation

La fonction statique FromError génère de manière synchrone une nouvelle instance de ara::core::Result<void, E> à partir d'un objet d'erreur e transmis en tant que rvalue [SWS_CORE_00835]. La fonction est définie dans l'en-tête ara/core/result.h et renvoie un ara::core::Result qui contient la valeur d'erreur [SWS_CORE_00835].

Gestion des erreurs et concurrence

L'opération offre une sécurité conditionnelle vis-à-vis des exceptions (conditionally exception safe) : elle garantit l'absence d'exceptions via noexcept pour autant que le type d'erreur E possède un constructeur de déplacement ne levant pas d'exception (std::is_nothrow_move_constructible<E>::value) [SWS_CORE_00835]. La fonction est classée comme non sûre pour les threads (not thread-safe) [SWS_CORE_00835]. Interprétation : cela devrait signifier que l'objet rvalue à déplacer doit être protégé contre les accès parallèles issus d'autres threads. Question Q-be29e8c3a7412b7a (ouverte)

Interaction

Au sein de la spécialisation ara::core::Result<void, E>, cette surcharge constitue le pendant de déplacement de la fonction de copie par lvalue [SWS_CORE_00834] et de la construction sur place via des packs de paramètres [SWS_CORE_00836]. Des surcharges rvalue comparables existent également dans le module core pour les types valeurs [SWS_CORE_00735] et les références [SWS_CORE_00906], complétées par des variantes respectives par lvalue ([SWS_CORE_00734], [SWS_CORE_00905]) et sur place ([SWS_CORE_00736], [SWS_CORE_00907]).

La fonction modèle statique FromError selon [SWS_CORE_00836] sert à générer, au sein de la spécialisation ara::core::Result<void, E>, un objet Result défaillant dont l'instance d'erreur du type E est construite directement sur place (« in-place ») à partir des arguments transmis args. La fonction ne participe à la résolution de surcharge que si std::is_constructible<E, Args&&...>::value est vrai, que le premier type du pack de paramètres dépaqueté ne correspond pas à E et n'est pas non plus une spécialisation de Result [SWS_CORE_00836].

Concernant la sécurité vis-à-vis des exceptions, la fonction est spécifiée comme conditionnellement sûre vis-à-vis des exceptions (« conditionally exception safe ») : elle est déclarée avec noexcept(std::is_nothrow_constructible<E, Args...>::value) [SWS_CORE_00836]. En ce qui concerne la concurrence, l'appel est considéré comme non sûr pour les threads (« not thread-safe ») [SWS_CORE_00836].

En interaction avec d'autres fonctions de la classe, cette méthode complète les surcharges destinées à la génération à partir d'objets d'erreur lvalue ([SWS_CORE_00834]) ou rvalue ([SWS_CORE_00835]) déjà existants. Interprétation : les restrictions SFINAE relatives à E et Result devraient garantir qu'en cas de transmission d'erreurs ou d'instances de Result déjà créées, les opérateurs de copie ou de déplacement respectifs soient choisis en priorité et que les ambiguïtés soient évitées. Question Q-2796f954bcaececa (ouverte) Des fonctions fabriques analogues sur place existent pour le type générique Result ([SWS_CORE_00736]) ainsi que pour les types références dans Result<T&, E> ([SWS_CORE_00907]).

Utilisation

La fonction membre statique FromValue() sert à créer un objet ara::core::Result de succès pour la spécialisation de modèle ara::core::Result<void, E> [SWS_CORE_00831]. Comme le type de résultat void ne transporte pas de données utiles, la fonction ne prend aucun paramètre d'entrée. L'appel s'effectue de manière synchrone et renvoie un Result qui représente une valeur void [SWS_CORE_00831]. La déclaration figure dans l'en-tête ara/core/result.h [SWS_CORE_00831].

Traitement des erreurs et sécurité vis-à-vis des exceptions

La fonction est munie de la spécification noexcept et classée comme totalement sûre du point de vue des exceptions (exception safe) [SWS_CORE_00831]. Comme FromValue() représente par définition une opération réussie, elle ne génère aucun état d'erreur et ne renvoie aucun code d'erreur. Aucun message d'erreur spécifique via DET ou DEM n'est défini pour cet appel.

concurrence

Conformément à la spécification, la fonction est classée comme sûre pour les threads (thread-safe) [SWS_CORE_00831]. Elle peut être appelée en parallèle depuis plusieurs threads sans mesures de synchronisation supplémentaires.

Interaction

La signature sans paramètre est exclusivement prévue pour Result<void, E> [SWS_CORE_00831]. Elle se distingue des surcharges générant des valeurs :

• Pour les types valeur Result<T, E>, il existe des variantes pour les lvalues [SWS_CORE_00731], les rvalues [SWS_CORE_00732] ainsi que des constructions in-place [SWS_CORE_00733].
• Pour les types référence Result<T&, E>, FromValue se lie à une référence lvalue [SWS_CORE_00904].

La fonction membre Resolve de la classe modèle ara::core::Result<void, E> sert au traitement des erreurs dans le cadre de la programmation générique [SWS_CORE_00867]. Si l'instance de Result contient une valeur normale, l'appel n'exécute aucune opération [SWS_CORE_00867]. Si l'instance contient au contraire une erreur, le callable f transmis en tant que paramètre est appelé [SWS_CORE_00867].

Le callable transmis f doit être compatible avec la signature de fonction void f(const E&), où E représente le type d'erreur [SWS_CORE_00867]. La fonction Resolve elle-même ne fournit aucune valeur de retour (void) [SWS_CORE_00867]. En matière de sécurité d'exécution, la fonction est spécifiée comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_00867]. Sa sécurité vis-à-vis des threads est conditionnelle et dépend directement de la sécurité vis-à-vis des threads du callable transmis f [SWS_CORE_00867].

Dans le système global, cette spécialisation se distingue des fonctions régulières Resolve pour les types valeur dans ara::core::Result<T, E> [SWS_CORE_00767] ainsi que pour les types référence dans ara::core::Result<T&, E> [SWS_CORE_00939], [SWS_CORE_00940] : alors que ces variantes renvoient la valeur contenue ou le résultat de l'appel du callable, la surcharge void sans valeur de retour existe exclusivement en tant que composant générique pour uniformiser les appels d'interface [SWS_CORE_00867].

La fonction membre Swap échange de manière synchrone le contenu de l'instance actuelle avec la référence transmise other [SWS_CORE_00845]. Elle relève du périmètre de la spécialisation ara::core::Result<void, E> issue du fichier d'en-tête ara/core/result.h et ne possède aucune valeur de retour [SWS_CORE_00845].

Concernant le traitement des erreurs, l'opération est classée comme conditionnellement sûre du point de vue des exceptions (conditionally exception safe) [SWS_CORE_00845]. L'assurance noexcept s'applique si et seulement si le type d'erreur E peut être à la fois construit par déplacement sans exception (std::is_nothrow_move_constructible<E>::value) et affecté par déplacement sans exception (std::is_nothrow_move_assignable<E>::value) [SWS_CORE_00845]. Aucun code d'erreur spécifique ni aucune notification à destination de DET ou DEM ne sont prévus pour cet appel [SWS_CORE_00845].

Concernant la concurrence, Swap est expressément spécifiée comme non sûre pour les threads (not thread-safe) [SWS_CORE_00845]. Un accès concurrent aux mêmes instances sans synchronisation externe devrait donc entraîner des courses aux données. Question Q-a8d4f130648765df (ouverte)

Dans l'interaction au sein de ara::core, la méthode constitue le fondement de la fonction modèle libre ara::core::swap, dont la condition noexcept est directement couplée à la fonction membre [SWS_CORE_00796]. Des opérations d'échange comparables existent pour le type générique ara::core::Result<T, E> [SWS_CORE_00745], la spécialisation de référence ara::core::Result<T&, E> [SWS_CORE_00917] ainsi que pour les objets Promise [SWS_CORE_00352] [SWS_CORE_06352].

La fonction membre ValueOr de la spécialisation ara::core::Result<void, E> sert principalement à faciliter les patrons de programmation générique et n'exécute aucune opération lors de son exécution ([SWS_CORE_00861]). Fournie via l'en-tête ara/core/result.h, la méthode accepte de manière synchrone un paramètre defaultValue de type de transfert U&& et ne fournit aucune valeur de retour (void) ([SWS_CORE_00861]).

En ce qui concerne la concurrence et le comportement vis-à-vis des exceptions, la fonction membre est spécifiée comme sûre pour les threads (thread-safe) et déclarée avec la syntaxe de spécificateur noexcept, ce qui garantit une sécurité totale vis-à-vis des exceptions ([SWS_CORE_00861]). Comme aucune vérification de l'état d'erreur ni aucune action n'a lieu, il n'existe ni codes d'erreur ni notifications à destination de DET ou DEM.

En interaction avec les autres déclinaisons de Result, cette fonction complète les surcharges basées sur des valeurs ([SWS_CORE_00761], [SWS_CORE_00762]) et sur des références ([SWS_CORE_00933], [SWS_CORE_00934]) de ValueOr. Alors que ces fonctions renvoient la valeur définie lorsqu'elle est présente ou fournissent sinon la valeur de remplacement transmise sous forme convertie, cette variante constitue un pendant neutre pour les opérations sans retour de valeur ([SWS_CORE_00861]). Interprétation : la valeur transmise defaultValue devrait être abandonnée sans être utilisée dans l'implémentation. Question Q-6097af779219e859 (ouverte) Cela permet aux développeurs d'écrire des algorithmes modèles génériques sans branchements spécifiques pour Result<void, E>.

La fonction membre ValueOrThrow de la spécialisation d'un modèle ara::core::Result<void, E> sert à la vérification synchrone du résultat de l'opération [SWS_CORE_00866]. Le type de valeur étant void, la fonction ne possède aucun paramètre et ne renvoie aucune valeur de retour [SWS_CORE_00866]. La déclaration est mise à disposition via l'en-tête ara/core/result.h [SWS_CORE_00866].

En cas de succès, la méthode retourne normalement ; en revanche, en présence d'un état d'erreur, elle lève une exception du type d'exception associé à l'erreur contenue (noexcept(false)) [SWS_CORE_00866]. En ce qui concerne la sécurité vis-à-vis des exceptions, l'opération est spécifiée comme not exception safe [SWS_CORE_00866].

Pour le contexte d'appel et la concurrence, les conditions aux limites suivantes s'appliquent :

• La fonction est classée comme thread-safe [SWS_CORE_00866].
• Si les exceptions C++ sont désactivées dans la chaîne d'outils du compilateur, cette fonction ne participe pas à la résolution de surcharge [SWS_CORE_00866].

En interaction avec le module core, cette spécialisation void complète les surcharges génériques de ara::core::Result<T, E>, qui renvoient des références sur les valeurs contenues ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]), ainsi que les spécialisations pour les types de référence ara::core::Result<T&, E> ([SWS_CORE_00938], [SWS_CORE_00949]).

La fonction membre modèle CheckError de la spécialisation ara::core::Result<void, E> vérifie de manière synchrone si l'instance actuelle contient une erreur spécifique [SWS_CORE_00865]. Pour ce faire, l'argument transmis error est converti au moyen de static_cast dans le type d'erreur E et comparé à la valeur de retour de l'état d'erreur interne Error() [SWS_CORE_00865]. L'appel s'effectue via l'en-tête #include "ara/core/result.h" [SWS_CORE_00865].

Les propriétés suivantes s'appliquent à l'utilisation et au contexte d'appel :

• Paramètres et valeur de retour : le paramètre de référence universelle error de type G&& reçoit l'erreur à vérifier [SWS_CORE_00865]. La fonction renvoie true si l'instance contient une erreur équivalente à error, et sinon false [SWS_CORE_00865].
• Concurrence et sécurité vis-à-vis des exceptions : l'opération est déclarée comme const noexcept, est considérée comme sûre vis-à-vis des exceptions (exception safe) et peut être appelée sans restriction de manière sûre pour les threads (thread-safe) [SWS_CORE_00865].

En interaction avec le module core, il existe des surcharges analogues de CheckError : la classe modèle primaire ara::core::Result met à disposition la même signature, également sûre pour les threads et sûre vis-à-vis des exceptions, avec noexcept [SWS_CORE_00765]. En revanche, la spécialisation de référence ara::core::Result<T&, E> possède certes le même mécanisme de comparaison et est sûre pour les threads, mais est explicitement spécifiée sans noexcept comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_00937].