Stocke de manière sûre du point de vue des types exactement une valeur issue d'un ensemble de types défini avec sécurité conditionnelle vis-à-vis des exceptions.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 223b5b60b80cProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Stocke de manière sûre du point de vue des types exactement une valeur issue d'un ensemble de types défini avec sécurité conditionnelle vis-à-vis des exceptions.
La classe modèle ara::core::Variant sert d'union sûre vis-à-vis des types pour le stockage et la gestion d'exactement une valeur issue d'un ensemble de types prédéfini [SWS_CORE_01649]. Elle prend en charge des mécanismes flexibles de construction, d'assignation et d'emplace, et permet de déterminer l'alternative active via index()[SWS_CORE_01665]. La particularité principale par rapport au standard réside dans les spécifications noexcept conditionnelles modifiées de l'ensemble des opérations modificatrices ainsi que dans la protection contre l'état valueless_by_exception()[SWS_CORE_01666].
Contexte
La classe modèle ara::core::Variant constitue une union sûre vis-à-vis des types pour l'AUTOSAR Adaptive Platform, incluse via l'en-tête ara/core/variant.h. Elle encapsule la gestion d'exactement une valeur issue d'une liste de types définie à la compilation (template <typename... Types> class Variant). La définition s'inspire fondamentalement du comportement de std::variant issu du standard C++ [variant], mais présente des écarts spécifiques à AUTOSAR en ce qui concerne la spécification des exceptions. La description de la classe fait référence à [basic.string] dans le jeu de métadonnées ; interprétation : il devrait s'agir d'une incohérence rédactionnelle, étant donné que toutes les exigences font référence de manière cohérente à la section standard [variant]. Question Q-809de1af74fcb689 (ouverte)
Cycle de vie
Une instance de ara::core::Variant passe par des phases de cycle de vie déterministes, de l'initialisation à la destruction en passant par les changements de valeur. La création s'effectue soit par le constructeur par défaut sans argument [SWS_CORE_01649], qui initialise la première alternative, soit par des constructeurs de copie et de déplacement [SWS_CORE_01650], [SWS_CORE_01651], soit par passage direct de valeur [SWS_CORE_01652]. De plus, des surcharges pour la construction in situ au moyen de in_place_type_t[SWS_CORE_01653], [SWS_CORE_01654] ainsi que de in_place_index_t[SWS_CORE_01655], [SWS_CORE_01656] sont disponibles, y compris en combinaison avec des listes d'initialisation.
À l'état standard, l'objet contient toujours une alternative valide dont l'indice basé sur zéro peut être déterminé avec la méthode index()[SWS_CORE_01665]. Si un changement de valeur échoue pendant une construction ou une assignation en raison de la levée d'une exception, l'instance passe à l'état valueless_by_exception()[SWS_CORE_01666]. L'objet demeure dans cet état jusqu'à ce qu'une réinitialisation réussie occupe à nouveau une alternative valide. Le destructeur détruit convenablement l'objet actuellement contenu et est déclaré conditionnellement sûr du point de vue des exceptions [SWS_CORE_01657].
Un flux d'utilisation typique comprend l'instanciation, l'assignation ou le remplacement du contenu, l'interrogation de l'état et l'échange de valeurs :
Initialisation : création d'une instance via l'un des constructeurs, par exemple par passage direct de valeur [SWS_CORE_01652] ou de manière explicitement liée au type au moyen de in_place_type_t[SWS_CORE_01653].
Contrôle de l'état : interrogation de l'indice de type actif via index()[SWS_CORE_01665] ainsi que protection contre les erreurs précédentes via valueless_by_exception()[SWS_CORE_01666].
Échange d'objets : échange efficace de deux instances de Variant via la fonction membre swap()[SWS_CORE_01667].
Le jeu d'enregistrements de spécification présent ne comportant que des fonctions membres, les opérations de lecture directe telles qu'un accès aux valeurs font défaut ; les fonctions d'accès et de visite (de façon analogue à std::get ou std::visit) sont vraisemblablement fournies sous forme de fonctions utilitaires libres dans l'espace de noms ara::core. Question Q-75847ac18088da57 (ouverte)
Scénarios d'erreur
Au cœur du traitement des erreurs se trouve la propriété de sécurité conditionnelle vis-à-vis des exceptions (conditionally exception safe). Alors que la bibliothèque standard prévoit des règles noexcept fixes pour std::variant, AUTOSAR s'en écarte délibérément : tous les constructeurs [SWS_CORE_01650], [SWS_CORE_01653], les opérateurs d'assignation [SWS_CORE_01658], les opérations emplace[SWS_CORE_01661], [SWS_CORE_01663], la fonction d'échange swap()[SWS_CORE_01667] ainsi que le destructeur [SWS_CORE_01657] sont conditionnellement noexcept. Leur garantie d'exception dépend directement des propriétés noexcept des constructeurs de types sous-jacents.
Si la construction d'une nouvelle valeur lève une exception lors d'une assignation ou d'un appel de emplace, le variant peut basculer dans un état intermédiaire invalide. Celui-ci est signalé via valueless_by_exception()[SWS_CORE_01666]. Seules les deux fonctions d'interrogation index()[SWS_CORE_01665] et valueless_by_exception()[SWS_CORE_01666] offrent une garantie noexcept sans restriction et sont totalement sûres vis-à-vis des exceptions.
Ce guide repose sur la spécification AUTOSAR pour l'Adaptive Platform (Release R25-11, module core) et a été préparé par un assistant de curation IA.
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 0fe1e0b61069ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre emplace construit une valeur alternative du type T directement dans une instance existante de ara::core::Variant[SWS_CORE_01661]. La fonction est mise à disposition via le fichier d'en-tête #include "ara/core/variant.h" et s'exécute de manière synchrone [SWS_CORE_01661]. Comme paramètres, elle prend des références de transfert universel args..., qui sont transmises au constructeur du type cible T, et renvoie une référence sur l'objet nouvellement créé [SWS_CORE_01661].
Concernant le traitement des erreurs, l'opération est déclarée comme conditionnellement sûre vis-à-vis des exceptions (« conditionally exception safe ») [SWS_CORE_01661]. Elle suit le comportement standard de variant, mais s'en écarte par une spécification conditionnelle noexcept : une exception est exclue si et seulement si std::is_nothrow_constructible<T, Args...>::value est satisfait [SWS_CORE_01661]. Aucun code d'erreur AUTOSAR spécifique ni message vers DET ou DEM n'est défini pour cette fonction de base.
Concernant la concurrence et le contexte d'appel, la spécification ne mentionne aucune garantie divergente. Interprétation : l'accès simultané en écriture de plusieurs threads à la même instance Variant via emplace ne devrait pas être thread-safe sans synchronisation externe, car AUTOSAR renvoie à la sémantique standard de variant. Question Q-4d9d118b9916a3dc (ouverte)
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : a346c9068921ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre emplace de ara::core::Variant issue de l’en-tête ara/core/variant.h sert à la création synchrone d’une alternative de type T directement dans la mémoire de l’instance existante [SWS_CORE_01662]. À cette occasion, une std::initializer_list<U> ainsi que des arguments transférés Args&&... args sont passés au constructeur du type. Comme valeur de retour, la fonction fournit une référence lvalue T& sur l’objet nouvellement initialisé [SWS_CORE_01662].
En ce qui concerne le traitement des erreurs et la gestion des exceptions, la fonction s’écarte de la définition standard dans [variant] : elle est classée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) et dispose d’une spécification noexcept conditionnelle [SWS_CORE_01662]. Un appel garantit l’absence d’exception pour autant que std::is_nothrow_constructible<T, std::initializer_list<U>&, Args&&...>::value s’évalue à true[SWS_CORE_01662]. Aucun code d’erreur AUTOSAR spécifique ou canal de signalement vers DET et DEM n’existe pour cet élément.
Concernant la concurrence et les conditions aux limites : étant donné que emplace modifie l’état de l’instance de variant, un appel concurrent sans synchronisation externe ne devrait pas être sûr pour les threads. Interprétation : avant la construction du nouvel objet, une valeur précédemment contenue est détruite, conformément au comportement général de [variant]. Question Q-548c84cc1d327030 (ouverte)
En combinaison avec des interfaces apparentées, la fonction constitue le pendant basé sur les types de la surcharge sans liste d'initialisation [SWS_CORE_01661] ainsi que des alternatives basées sur les indices [SWS_CORE_01663] et [SWS_CORE_01664]. Des concepts d'interface similaires se retrouvent pour ara::core::Optional[SWS_CORE_01120] ainsi que pour des conteneurs tels que ara::core::Vector[SWS_CORE_01366] ou ara::core::Map[SWS_CORE_01458], les opérations emplace des conteneurs n'étant, à la différence de celle-ci, pas sans danger pour les exceptions.
Cette note d'utilisation a été générée automatiquement sur la base des données de spécification d'AUTOSAR R25-11.
template <std::size_t I, typename... Args> variant_alternative_t< I, Variant< Types... > > & emplace (Args &&... args) noexcept({<cond-noexcept-11>});
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : f8cbed1f17b1ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction membre emplace de la classe ara::core::Variant ([SWS_CORE_01663]) issue du fichier d'en-tête ara/core/variant.h sert à la construction directe de l'alternative déterminée par l'indice de template I dans l'espace mémoire existant de l'objet. Les arguments Args&&... args sont transmis comme paramètres. L'appel est synchrone et renvoie une référence vers la valeur nouvellement créée de type variant_alternative_t<I, Variant<Types...>> ([SWS_CORE_01663]). Le comportement est conforme à la définition dans [variant] ([SWS_CORE_01663]).
Gestion des erreurs et sécurité vis-à-vis des exceptions
En guise d'écart par rapport au standard C++, la spécification définit une clause noexcept({<cond-noexcept-11>}) conditionnelle ainsi que la propriété conditionally exception safe ([SWS_CORE_01663]). La levée d'exceptions dépend vraisemblablement du fait que le constructeur de l'alternative cible soit ou non sûr vis-à-vis des exceptions pour les types transmis Args.... Question Q-189fe417e9ef4980 (ouverte) Des codes d'erreur spécifiques, des valeurs de retour en cas d'erreur ou des notifications au DET ou au DEM ne sont pas spécifiés pour cette fonction.
Interaction et alternatives
Au sein du module core et du type ara::core::Variant, la fonction est intégrée dans un système d'autres surcharges :
Initialisation basée sur l'indice avec une std::initializer_list sous [SWS_CORE_01664].
Création basée sur le type d'une alternative via le nom de type T au moyen de [SWS_CORE_01661] ou en combinaison avec std::initializer_list via [SWS_CORE_01662].
template <std::size_t I, typename U, typename... Args> variant_alternative_t< I, Variant< Types... > > & emplace (std::initializer_list< U > il, Args &&... args) noexcept( {<cond-noexcept-12>});
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : a600ca3cb60dProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre emplace issue de ara/core/variant.h construit de manière synchrone une nouvelle valeur d'alternative directement sur place au sein d'une instance existante de ara::core::Variant[SWS_CORE_01664]. Le type à adresser est alors déterminé de manière fixe par l'indice de template I. L'appel reçoit une liste d'initialisateurs il du type std::initializer_list<U> ainsi que des arguments optionnels args et renvoie une référence vers la valeur nouvellement créée de type variant_alternative_t<I, Variant<Types...>>&[SWS_CORE_01664].
Pour le traitement des erreurs, l'opération est classée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) et pourvue d'un noexcept conditionnel [SWS_CORE_01664]. L'évaluation de la condition {<cond-noexcept-12>} devrait vraisemblablement dépendre du fait que le constructeur du type cible avec il et args ne lève pas d'exceptions. Question Q-87f90253fc61c883 (ouverte) Des codes d'erreur spécifiques ainsi que des messages au DET ou au DEM ne sont pas définis dans la spécification ; le comportement en cas d'exception suit, à l'exception de la déclaration noexcept, le comportement standard de [variant][SWS_CORE_01664].
Au sein de ara::core::Variant, la fonction complète la création basée sur l'indice sans liste d'initialisateurs [SWS_CORE_01663] ainsi que les deux variantes basées sur les types [SWS_CORE_01661] et [SWS_CORE_01662]. Des fonctions emplace analogues pour la construction directe sur place existent également dans le module core pour ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]) ainsi que pour des conteneurs tels que ara::core::Vector ([SWS_CORE_01366]) et ara::core::Map ([SWS_CORE_01458]).
Cette note d'utilisation a été générée de manière automatisée sur la base de la spécification.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : fb0fc41b4094ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre index de la classe ara::core::Variant sert à interroger de manière synchrone l'indice basé sur zéro du type actuellement contenu conformément à la spécification [SWS_CORE_01665]. Elle se comporte de manière analogue à l'utilisation correspondante dans le type C++ standard std::variant (« As per corresponding usage in [variant] »), ne prend aucun paramètre et renvoie l'indice actuel sous la forme d'un std::size_t. Elle est déclarée dans l'en-tête ara/core/variant.h et qualifiée de constexpr ainsi que noexcept.
Concernant le traitement des erreurs et la sécurité vis-à-vis des exceptions, la méthode est spécifiée comme exception safe[SWS_CORE_01665]. Étant donné qu'elle est déclarée noexcept, elle ne lève elle-même aucune exception et ne déclenche aucune condition d'erreur. Les appelants peuvent évaluer l'indice retourné afin de s'assurer, avant d'accéder à des valeurs alternatives, de quel type est actif dans ara::core::Variant.
En interaction avec les fonctions d'accès typées ara::core::get, index joue un rôle central : les surcharges de get pour les lvalues et les rvalues vérifient explicitement la condition variant.index() != I selon [SWS_CORE_01613], [SWS_CORE_01614], [SWS_CORE_01615] et [SWS_CORE_01616]. Si l'indice ne correspond pas à l'indice de position demandé I, la violation IsoStdBadVariantAccessViolation est déclenchée, contrairement à std::bad_variant_access. Une comparaison préalable au moyen de index() empêche cet accès erroné au moment de l'exécution.
En ce qui concerne la concurrence, la méthode en tant qu'opération const est sûre pour les accès en lecture concurrents sur le même variant, tant qu'aucune modification concurrente n'a lieu ; une synchronisation interne contre les accès en écriture parallèles ne devrait pas être présente. Question Q-12e0dad0a6b8c5d0 (ouverte)
Ce texte a été généré par une IA sur la base de la spécification AUTOSAR R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 015c4319d2b5ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction membre valueless_by_exception de la classe ara::core::Variant est mise à disposition dans le module core via le fichier d'en-tête #include "ara/core/variant.h" ([SWS_CORE_01666]). Conformément à sa signature constexpr bool valueless_by_exception () const noexcept;, elle ne requiert aucun paramètre d'appel et renvoie de manière synchrone une valeur booléenne ([SWS_CORE_01666]). La signification fonctionnelle s'aligne sur la sémantique usuelle de [variant] (« As per corresponding usage in [variant] ») ([SWS_CORE_01666]). Interprétation : l'état retourné true signale probablement à l'appelant qu'une affectation de valeur ou un changement de type antérieur a été interrompu par la survenue d'une exception et que l'objet Variant ne représente donc temporairement aucun état valide. Question Q-af7c00c7eb4ef5a1 (ouverte)
Gestion des erreurs et sécurité vis-à-vis des exceptions
Concernant le comportement en cas d'erreur, la méthode est déclarée comme noexcept et formellement classée comme exception safe ([SWS_CORE_01666]). Il n'existe pas de cas d'erreur propre lors de l'interrogation ; la fonction ne lève pas d'exceptions C++ ([SWS_CORE_01666]). Aucun code d'erreur spécifique, description de retour ou notification à des entités de diagnostic et de surveillance des erreurs telles que DET ou DEM n'est défini pour cet élément ([SWS_CORE_01666]).
Concurrence et restrictions
Étant donné que valueless_by_exception est spécifiée comme méthode const et constexpr, aucun accès modificateur à l'état interne de l'objet n'a lieu pendant l'exécution ([SWS_CORE_01666]). Interprétation : des interrogations en lecture simultanées de la même instance à partir de plusieurs threads devraient pouvoir être exécutées en toute sécurité sans synchronisation particulière, tant que des opérations d'écriture concurrentes restent exclues. Question Q-5c28f8cef1c1f097 (ouverte)
Cette note d’utilisation a été générée de manière automatisée sur la base d’AUTOSAR R25-11.
gemini-3.8-flash-low· 2026-10-13 · Original allemand