template <typename T, typename E = ErrorCode> class Result final {...};
This class is a type that contains either a value or an error. The implementation shall flag the condition E != ara::core::ErrorCode as a compile error.
Encapsule soit une valeur de succès, soit une valeur d'erreur pour la transmission synchrone de résultats sans exception.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 33e53dcae988ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Encapsule soit une valeur de succès, soit une valeur d'erreur pour la transmission synchrone de résultats sans exception.
La classe constitue un conteneur à sûreté de typage qui accueille soit une valeur utile, soit un code d'erreur, afin de transmettre des résultats de calcul de manière synchrone et sans exceptions C++ [SWS_CORE_00751]. Les appelants créent des instances via des constructeurs dédiés ou des fonctions de fabrique, puis évaluent le résultat selon l'état via des fonctions de vérification et d'accès telles que l'accès à la valeur ou à l'erreur. Comme contrainte essentielle, le type d'erreur sous-jacent doit impérativement correspondre au code d'erreur standard, car des affectations de types divergentes sont rejetées au moment de la compilation. De plus, les fonctions de déclenchement d'exceptions présupposent un environnement de compilation avec exceptions C++ activées [SWS_CORE_00766].
Contexte
La classe ara::core::Result est la structure centrale de l'AUTOSAR Adaptive Platform pour le renvoi synchrone et typé de résultats d'opérations sans recours obligatoire aux exceptions C++. Elle représente une union disjointe (Tagged Union) qui contient à tout instant soit une valeur utile de type value_type (T), soit une erreur de type error_type (E) [SWS_CORE_00711][SWS_CORE_00712]. Par défaut, ara::core::ErrorCode fait office de type pour E ; les définitions d'erreurs divergentes sont empêchées par les implémentations dès le moment de la compilation par une erreur de compilation.
Dans l'architecture applicative, ara::core::Result sert d'intermédiaire entre les services appelés et les consommateurs. Les services instancient l'objet pour renvoyer le statut, tandis que les consommateurs déclenchent un traitement ultérieur via des tests d'état tels que [SWS_CORE_00751] ou des chaînages fonctionnels tels que [SWS_CORE_00768]. De plus, l'état peut être converti en ara::core::Optional via [SWS_CORE_00770] (Ok) et [SWS_CORE_00772] (Err).
ara::core::Result possède la donnée contenue de manière exclusive et gère sa durée de vie. Elle prend en charge une sémantique de valeur complète via des constructeurs de copie et de déplacement ([SWS_CORE_00725], [SWS_CORE_00726]) ainsi que des opérateurs d'affectation correspondants ([SWS_CORE_00741], [SWS_CORE_00742]). Un changement de contenu des instances existantes est possible au moyen de Swap[SWS_CORE_00745] ou par écrasement in-place via EmplaceValue[SWS_CORE_00743] respectivement EmplaceError[SWS_CORE_00744].
Le destructeur libère l'élément actif et est considéré comme trivialement destructible si aussi bien T que E sont trivialement destructibles [SWS_CORE_00727]. En ce qui concerne la concurrence, les accès en pure lecture sont thread-safe, tandis que les opérations modificatrices telles que EmplaceValue, EmplaceError, les affectations par déplacement ou Swap ne sont pas thread-safe et nécessitent une synchronisation externe.
Vérification d'état : l'appelant vérifie au moyen de HasValue()[SWS_CORE_00751] ou de l'opérateur de conversion explicite operator bool()[SWS_CORE_00752] si une valeur est présente. Ce dernier est désactivé lorsque T est lui-même de type bool.
Transformation fonctionnelle : alternativement, Bind()[SWS_CORE_00768] permet un traitement ultérieur monadique : le callable transmis n'est exécuté que si une valeur utile est contenue ; une erreur existante est propagée sans modification dans la nouvelle instance de Result. Des solutions de repli peuvent être représentées avec Resolve()[SWS_CORE_00767].
L'appel de Error() en présence d'une valeur utile conduit à la violation ResultWithNoErrorViolation ([SWS_CORE_00757], [SWS_CORE_00776]).
Interprétation : le déclenchement d'une telle violation de précondition devrait typiquement conduire à l'interruption immédiate du processus dans les environnements d'exécution, car le standard classe ces états comme des erreurs de programmation graves. Question Q-15376f67084c4be6 (ouverte) Pour éviter des interruptions brutales, des méthodes défensives peuvent être utilisées : ValueOr() ([SWS_CORE_00761], [SWS_CORE_00762]) et ErrorOr() ([SWS_CORE_00763], [SWS_CORE_00764]) renvoient une valeur par défaut spécifiée en l'absence d'élément. Des variantes optionnelles telles que Ok() ([SWS_CORE_00770], [SWS_CORE_00771]) et Err() ([SWS_CORE_00772], [SWS_CORE_00773]) encapsulent l'accès sans exception.
Si un traitement des exceptions est souhaité, ValueOrThrow() ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]) lève en cas d'erreur l'exception C++ associée à l'erreur. Si les exceptions C++ sont désactivées dans le compilateur, ValueOrThrow() est retiré de la résolution de surcharge [SWS_CORE_00766] ; de même, la surcharge lvalue non constante de operator* est désactivée dans ce cas [SWS_CORE_00774].
Ce guide a été généré par un assistant de curation IA sur la base des exigences de spécification d'AUTOSAR Adaptive R25-11.
Return the contained value or the given default value. If *this contains a value, it is returned. Otherwise, the specified default value is returned, static_cast’d to T
Return the contained error or the given default error. If *this contains an error, it is returned. Otherwise, the specified default error is returned, static_cast’d to E
Apply the given Callable to the value of this instance, and return a new ara::core:: Result with the result of the call.
The Callable is expected to be compatible to one of these two interfaces: • Result<XXX, E> f(const T&); • <ARTechTerm{XXX f(const T&);}> • <ARNewline{}> • <ARNewline{}> • <ARTechTerm{Callable}> • Result<XXX> or a XXX directly, where XXX can be any type that is suitable for use by ara::core::Result.
The return type of this function is decltype(f(Value())) for a template argument F that returns a ara::core::Result type, and it is Result<decltype(f(Value())), E> for a template argument F that does not return a ara::core::Result type.
If this instance does not contain a value, a new Result<XXX, E> is still created and returned, with the original error contents of this instance being copied into the new instance.}>}
Return the contained error or the given default error. If *this contains an error, it is returned. Otherwise, the specified default error is returned, static_cast’d to E
Return the contained error or the given default error. If *this contains an error, it is std:: move’d into the return value. Otherwise, the specified default error is returned, static_cast’d to E
Build a new ara::core::Result from an error that is constructed in-place from the given arguments. This function shall not participate in overload resolution unless: • std::is_constructible<E, Args&&...>::value == true and • the first type of the expanded parameter pack is not E and • the first type of the expanded parameter pack is not a specialization of ara::core::Result
Build a new ara::core::Result from a value that is constructed in-place from the given arguments. This function shall not participate in overload resolution unless: • std::is_constructible<T, Args&&...>::value == true and • the first type of the expanded parameter pack is not T and • the first type of the expanded parameter pack is not a specialization of ara::core::Result
Return the contained value or return the result of a function call.
If *this contains a value, it is returned. Otherwise, the specified callable is invoked and its return value which is to be compatible to type T is returned from this function.
The Callable is expected to be compatible to this interface: T f(const E&);
Return the contained value or the given default value. If *this contains a value, it is returned. Otherwise, the specified default value is returned, static_cast’d to T
Return the contained value or the given default value. If *this contains a value, it is returned. Otherwise, the specified default value is returned, static_cast’d to T
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 38c9cb36d652ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation et appel
La fonction membre synchrone ValueOrThrow de la classe ara::core::Result ([SWS_CORE_00766]) est incluse via l'en-tête ara/core/result.h ([SWS_CORE_00766]). Elle est appelée sans paramètre sur une instance de lvalue constante et renvoie une référence constante (const T &) vers la valeur stockée dans l'objet ([SWS_CORE_00766]).
Traitement des erreurs et comportement vis-à-vis des exceptions
Si l'instance Result ne contient aucune valeur, mais un état d'erreur, la fonction lève l'exception C++ associée à l'erreur ([SWS_CORE_00766]). La spécification classe la fonction comme non sûre vis-à-vis des exceptions (not exception safe) ([SWS_CORE_00766]) ; interprétation : ce classement devrait être dû au fait qu'une exception est levée de manière intentionnelle en cas d'erreur. Question Q-0f4ebba70af6e48c (ouverte)
Concurrence et restrictions
L'opération est spécifiée comme thread-safe (thread-safe) ([SWS_CORE_00766]). Une condition limite essentielle s'applique : 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 (overload resolution) ([SWS_CORE_00766]).
Interaction dans le framework Result
La fonction complète des surcharges et spécialisations associées au sein de ara::core::Result :
Pour les lvalues modifiables, il existe la variante avec retour de T & ([SWS_CORE_00778]).
Pour les instances de rvalue, la surcharge de déplacement avec retour de T && est disponible ([SWS_CORE_00769]).
Pour les résultats void, il existe la spécialisation ara::core::Result<void, E> sans valeur de retour ([SWS_CORE_00866]).
Pour les types de référence ara::core::Result<T &, E>, des surcharges de référence constante et non constante correspondantes sont disponibles ([SWS_CORE_00938], [SWS_CORE_00949]).
Cette note d'utilisation a été générée de manière automatisée et sert de guide d'orientation. Seules les spécifications d'AUTOSAR font foi.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : bf00696cade5Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre ValueOrThrow() && est mise à disposition via l'en-tête #include "ara/core/result.h" et sert à l'accès synchrone à la valeur encapsulée dans une instance ara::core::Result ([SWS_CORE_00769]). Grâce à la qualification rvalue (&&), la fonction est appelée sur des objets rvalue et renvoie une référence rvalue (T &&) sur la valeur contenue [SWS_CORE_00769].
Gestion des erreurs et conditions limites
Si l'objet Result contient une valeur d'erreur, la méthode lève le type d'exception associé à l'erreur ([SWS_CORE_00769]). La spécification classe l'exécution comme non sûre vis-à-vis des exceptions (not exception safe), mais la définit expressément comme thread-safe (thread-safe) [SWS_CORE_00769]. Une exigence contraignante concerne la chaîne d'outils : si les exceptions C++ sont désactivées dans le compilateur, la fonction ne doit en aucun cas participer à la résolution de surcharge [SWS_CORE_00769].
Interaction au sein du jeu de surcharges
La méthode [SWS_CORE_00769] fait partie d'un ensemble coordonné de surcharges pour ValueOrThrow au sein de ara::core::Result :
Pour les lvalues, la surcharge constante [SWS_CORE_00766] (retour : const T &) et la variante non constante [SWS_CORE_00778] (retour : T &) sont disponibles.
Pour les résultats void, la spécialisation ara::core::Result<void, E> propose la fonction [SWS_CORE_00866] sans valeur de retour.
Pour les types de référence, ara::core::Result<T &, E> couvre avec [SWS_CORE_00938] (constante) et [SWS_CORE_00949] (non constante) les retours par référence correspondants.
Cette note d'utilisation a été générée automatiquement sur la base de la spécification AUTOSAR Adaptive R25-11.
Return a reference to the contained value or throw an exception.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : ddfa99362222ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction membre ValueOrThrow[SWS_CORE_00778] de la classe ara::core::Result (en-tête #include "ara/core/result.h") permet l'accès synchrone à la valeur contenue. La signature de la fonction étant dotée du qualificateur de référence &, elle peut être appelée exclusivement sur des instances lvalue non constantes. Elle n'attend aucun paramètre d'entrée et renvoie une référence modifiable (T&) sur la valeur encapsulée.
Gestion des erreurs et conditions limites
Si l'objet ne contient pas de valeur mais une erreur, ValueOrThrow lève de manière synchrone l'exception associée à l'erreur (noexcept(false)) [SWS_CORE_00778]. La fonction est spécifiée comme not exception safe[SWS_CORE_00778] ; interprétation : cela devrait signifier qu'en cas d'erreur, le flux d'exécution est interrompu par la levée de l'exception et qu'aucune garantie supplémentaire de récupération ou de rollback n'est accordée. Si les exceptions C++ sont désactivées dans la chaîne d'outils du compilateur, la fonction ne participe impérativement pas à la résolution de surcharge [SWS_CORE_00778]. En matière de concurrence, l'exécution est indiquée comme thread-safe [SWS_CORE_00778]. Question Q-11aed84264f3411f (ouverte)
Interaction
La fonction fait partie d'une famille de surcharges pour l'accès aux valeurs dans ara::core::Result :
Pour les instances constantes, la surcharge avec retour de const T& est disponible [SWS_CORE_00766].
Pour les objets rvalue, il existe une variante avec sémantique de déplacement qui fournit T&&[SWS_CORE_00769].
Pour les spécialisations avec des types de référence (Result<T&, E>), des surcharges correspondantes pour les références modifiables [SWS_CORE_00949] ainsi que les références constantes [SWS_CORE_00938] sont disponibles.
Dans le cas d'instances sans valeur (Result<void, E>), la méthode vérifie uniquement la présence d'une erreur et déclenche le cas échéant l'exception [SWS_CORE_00866].
Ce texte a été généré par un système d'IA et s'appuie sur la spécification AUTOSAR Adaptive Release R25-11.
gemini-3.8-flash-low· 2026-10-13 · Original allemand