classe ara::core::Map

Utilisation

La fonction d’accès synchrone aux éléments at de la classe ara::core::Map ([SWS_CORE_01456]) sert à la récupération contrôlée d’une valeur associée à une clé existante. Elle est fournie via l’en-tête ara/core/map.h. En tant que paramètre d’entrée, elle accepte une référence de clé const key_type &x et renvoie une référence modifiable mapped_type & sur la valeur correspondante ([SWS_CORE_01456]). La sémantique correspond fondamentalement à l’utilisation habituelle de std::map ; la surcharge distincte [SWS_CORE_01457] est disponible pour les instances constantes.

Gestion des erreurs et conditions limites

En cas d’erreur, la fonction s’écarte délibérément du comportement standard ISO : si l’élément indiqué x n’est pas présent dans le conteneur, une IsoStdOutOfRangeViolation est déclenchée au lieu d’une exception C++ classique de type std::out_of_range ([SWS_CORE_01456]). La signature est explicitement déclarée comme noexcept et classifiée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_01456]).

Interaction

Le concept consistant à signaler les dépassements de plage via IsoStdOutOfRangeViolation est mis en œuvre de manière uniforme à l’échelle du module :

• Au sein de ara::core::Map, la surcharge en lecture avec const présente le même comportement en cas d’erreur ([SWS_CORE_01457]).
• Des fonctions at correspondantes avec IsoStdOutOfRangeViolation existent pour ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]), ara::core::StringView ([SWS_CORE_02133]) ainsi que ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).
• Dans l’ensemble du système, la violation déclenchée devrait probablement être liée à des mécanismes d’interruption et de terminaison tels que AddAbortHandler ([SWS_CORE_00054]). Question Q-9427d214713f7508 (ouverte)

Utilisation

La fonction membre at conformément à [SWS_CORE_01457] permet l’accès synchrone en lecture à un élément au sein d’une instance de ara::core::Map via l’en-tête #include "ara/core/map.h". La clé recherchée x est transmise en tant que paramètre sous forme de const key_type &. Si la recherche aboutit, la méthode renvoie une référence constante vers la valeur correspondante (const mapped_type &).

Traitement des erreurs et comportement face aux exceptions

Le comportement correspond en principe au comportement standard de std::map::at, mais présente un écart spécifique : si la clé x n’est pas trouvée dans le conteneur, une IsoStdOutOfRangeViolation est levée conformément à [SWS_CORE_01457] au lieu de std::out_of_range. La fonction étant spécifiée avec noexcept, cette violation ne conduit pas à une exception C++ régulière ; cela entraîne vraisemblablement l’interruption contrôlée du processus via les mécanismes de gestion d’erreur tels qu’ils peuvent être enregistrés dans le contexte de [SWS_CORE_00054]. Question Q-d7dd2c332f88ed14 (ouverte)

Concurrence et interaction

En tant que méthode constante, l’appel est éligible pour un accès concurrent en lecture, pour autant qu’aucun accès concurrent modificateur n’ait lieu sur la même instance de map. Outre cette interface constante, il existe avec [SWS_CORE_01456] une surcharge non constante qui renvoie une référence modifiable. La même stratégie de signalement des violations de plage au moyen de IsoStdOutOfRangeViolation est également mise en œuvre de manière cohérente dans d’autres conteneurs de base adaptatifs, par exemple pour ara::core::Array ([SWS_CORE_01274]) et ara::core::Vector ([SWS_CORE_01354]).

La fonction membre clear de la classe ara::core::Map sert à vider complètement le contenu du conteneur conformément à la spécification dans [SWS_CORE_01485]. La fonction nécessite l'inclusion du fichier d'en-tête #include "ara/core/map.h". La sémantique d'appel et le comportement s'orientent d'après l'utilisation correspondante de la norme ISO C++ pour les maps associatives standard ([map]).

En ce qui concerne l'interface et le traitement des erreurs, la fonction présente les propriétés suivantes :

• Paramètres et valeur de retour : l'opération possède la signature void clear () noexcept;, ne prend aucun paramètre et ne renvoie aucune valeur de retour [SWS_CORE_01485].
• Sécurité vis-à-vis des exceptions : la fonction est explicitement déclarée comme noexcept et spécifiée comme exception safe [SWS_CORE_01485]. Elle ne lève ainsi aucune exception C++ en cas d'erreur.
• Exécution synchrone : l'appel est exécuté de manière synchrone sur l'instance ; après le retour, le conteneur devrait être vide (taille 0). Question Q-1d0cf2a1a33d818e (ouverte)

Dans le module core, le nettoyage des conteneurs standard suit un paradigme uniforme. Des fonctions clear analogues avec une signature et une sécurité vis-à-vis des exceptions identiques se trouvent par exemple pour les conteneurs séquentiels dans ara::core::Vector selon [SWS_CORE_01375] (ara/core/vector.h), ainsi que pour les chaînes de caractères dans ara::core::BasicString selon [SWS_CORE_03057] (ara/core/string.h). Les développeurs peuvent compter, pour l'ensemble des conteneurs, sur la sémantique standard de C++ habituelle et sur l'absence garantie d'exceptions.

La méthode template contains de la classe ara::core::Map sert à vérifier de manière synchrone si une clé recherchée existe dans un conteneur associatif [SWS_CORE_01497]. Elle est fournie via l'en-tête #include "ara/core/map.h" et appelée en tant que fonction membre constante (const) sur une instance de ara::core::Map [SWS_CORE_01497]. Comme paramètre d'appel, elle accepte une référence constante const K &x vers la clé à rechercher et fournit une valeur de retour de type bool [SWS_CORE_01497].

Concernant sa sémantique, la spécification renvoie à l'utilisation correspondante dans [map] [SWS_CORE_01497]. Cela devrait être interprété comme une reprise du comportement de std::map::contains, selon lequel la méthode renvoie true si et seulement si une clé équivalente est contenue dans la map, et sinon false. Question Q-664d5a3d099db549 (ouverte)

En matière de robustesse et de traitement des erreurs, la fonction est explicitement classée comme not exception safe [SWS_CORE_01497]. Il n'existe pas de codes d'erreur AUTOSAR spécifiques ni de notifications destinées à DET ou DEM pour cette opération. Les appelants doivent prendre en compte le fait que lors de l'exécution, vraisemblablement déclenchée par des comparaisons de clés ou des conversions du type K, des exceptions peuvent être levées et propagées vers l'extérieur. Question (ouverte)

Comme contains ne modifie pas l'état de la map en tant qu'opération de lecture const, les accès en lecture simultanés à la même instance ne sont généralement pas critiques, tandis que les modifications concurrentes en écriture sur le conteneur devraient nécessiter une synchronisation externe. Question Q-f3ca0e3d094f8f0a (ouverte)

Utilisation et sémantique

La fonction membre contains appartient à la portée de la classe ara::core::Map et est fournie via le fichier d'en-tête ara/core/map.h [SWS_CORE_01510]. La fonction possède la signature bool contains (const key_type &x) const; et s'exécute de manière synchrone. Elle sert à vérifier si un élément avec la clé x est présent dans le conteneur. La spécification fait référence au comportement correspondant dans [map], ce par quoi la sémantique du conteneur standard C++ std::map::contains est vraisemblablement désignée, laquelle renvoie true si la clé est présente et false dans le cas contraire. Question Q-fea394bd408bf925 (ouverte)

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

Le comportement de contains est expressément classé dans la spécification comme not exception safe [SWS_CORE_01510]. Aucun code d'erreur spécifique, domaine d'erreur ainsi que message DET ou DEM n'est défini dans le périmètre de la spécification. Les appelants doivent donc prendre en compte qu'aucune garantie de sécurité face aux exceptions n'est accordée lors de la recherche et que les exceptions survenant doivent être traitées.

Concurrence et restrictions

Concernant la sécurité des threads, la spécification ne formule aucune déclaration explicite dans [SWS_CORE_01510]. Puisqu'il s'agit d'une fonction membre constante (const), l'état du conteneur n'est pas modifié. Interprétation : des accès concurrents en lecture devraient être autorisés, alors que des modifications simultanées en écriture sur la même instance nécessitent une synchronisation externe. Question Q-7d8ce1efc81ec781 (ouverte)

Interaction dans le module core

Par rapport aux autres fonctions de vérification d'état du module core — telles que HasValue [SWS_CORE_00751] ou CheckError [SWS_CORE_00765] dans ara::core::Result, qui sont définies comme exception safe et noexcept —, contains dans ara::core::Map n'offre aucune garantie noexcept et est déclarée comme non sûre vis-à-vis des exceptions [SWS_CORE_01510].

La fonction membre synchrone count de la classe ara::core::Map détermine, au moyen de la clé transmise x de type const key_type&, combien de fois cette clé apparaît dans le conteneur, et renvoie le résultat sous forme de size_type [SWS_CORE_01494]. La déclaration s'effectue via l'en-tête #include "ara/core/map.h" [SWS_CORE_01494]. Interprétation : conformément à la référence au comportement standard dans [map], la valeur de retour devrait être soit 0, soit 1 pour des clés uniques. Question Q-a713cfc1019b40d0 (ouverte)

Concernant le traitement des erreurs, la fonction est expressément classée selon la spécification comme « not exception safe » [SWS_CORE_01494]. Aucun code d'erreur spécifique ni message DET/DEM n'est défini ; si l'opération de comparaison de clés lève une exception, celle-ci est vraisemblablement propagée directement à l'appelant. Question (ouverte)

Concernant la concurrence et les restrictions, il s'agit d'une opération constante (const) [SWS_CORE_01494]. Interprétation : des accès concurrents en lecture à la même instance de ara::core::Map devraient être possibles sans course aux données, alors que des opérations modificatrices simultanées doivent être protégées par une synchronisation externe. Question (ouverte)

En interaction avec des exigences connexes, il existe avec [SWS_CORE_01495] une surcharge template template <class K> size_type count (const K &x) const au sein de ara::core::Map. Celle-ci permet des requêtes de recherche hétérogènes avec des types de comparaison compatibles K, sans devoir obligatoirement créer au préalable un objet temporaire de type key_type, mais est soumise à la même classification quant à la sécurité vis-à-vis des exceptions [SWS_CORE_01495].

La fonction membre template count de la classe ara::core::Map vérifie de manière synchrone la présence d'éléments sur la base d'une clé et en détermine le nombre [SWS_CORE_01495]. La fonction est déclarée dans l'en-tête ara/core/map.h et renvoie le nombre d'éléments trouvés sous forme de size_type [SWS_CORE_01495]. Conformément à la référence spécifiée à l'utilisation dans [map], l'appel fournit la valeur 1 en présence de clés uniques si un élément correspondant existe, et 0 dans le cas contraire [SWS_CORE_01495].

En interaction directe avec la surcharge count(const key_type&) [SWS_CORE_01494], cette variante autorise le passage de n'importe quel type de clé compatible const K& [SWS_CORE_01495]. Interprétation : la modélisation sous forme de template devrait être conçue pour des opérations de recherche hétérogènes, afin d'effectuer des comparaisons sans conversion préalable en un objet key_type temporaire [SWS_CORE_01495]. Question Q-e2572768e5600da7 (ouverte) Cela permet d'éviter des allocations inutiles et des coûts de conversion lors des requêtes de recherche.

Concernant la sécurité face aux exceptions, la méthode est déclarée comme non sûre au regard des exceptions (not exception safe) [SWS_CORE_01495], à l'instar de la surcharge apparentée [SWS_CORE_01494]. Il n'existe aucun canal d'erreur spécifique tel que DET ou DEM pour cette opération de conteneur [SWS_CORE_01495] ; les éventuelles exceptions de l'opérateur de comparaison sous-jacent se répercutent sur l'appelant. La méthode étant qualifiée par const, elle ne modifie pas le conteneur [SWS_CORE_01495] ; les accès concurrents en lecture sont sûrs, mais les accès concurrents en écriture requièrent une synchronisation externe.

Utilisation

La fonction membre crbegin de la classe ara::core::Map est fournie via le fichier d'en-tête #include "ara/core/map.h" [SWS_CORE_01450]. Elle ne prend aucun paramètre et renvoie de manière synchrone un const_reverse_iterator sur le premier élément de l'ordre inverse [SWS_CORE_01450]. La sémantique fonctionnelle suit la mention de la spécification « As per corresponding usage in [map] » [SWS_CORE_01450] ; cela devrait vraisemblablement correspondre à la sémantique de std::map::crbegin de la norme C++. Question Q-0ad5de7dada37aa8 (ouverte)

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

Aucun code d'erreur spécifique, message DET ou DEM n'est prévu pour cet appel. Selon la spécification, la fonction est déclarée avec noexcept et classée comme sûre vis-à-vis des exceptions (« exception safe ») [SWS_CORE_01450], de sorte qu'aucune exception ne survient lors de l'exécution.

Concurrence et restrictions

En tant que méthode qualifiée const, crbegin ne modifie pas l'objet ara::core::Map [SWS_CORE_01450]. L'itérateur résultant autorise exclusivement des accès en lecture aux éléments contenus dans le conteneur.

Interaction

Le concept d'itération est harmonisé pour l'ensemble des conteneurs dans AUTOSAR Adaptive Core :

• ara::core::Vector [SWS_CORE_01342] et ara::core::BasicString [SWS_CORE_03049] fournissent des méthodes const noexcept fonctionnellement identiques.
• Pour ara::core::Array [SWS_CORE_01260], ara::core::Span [SWS_CORE_01978] et ara::core::StringView [SWS_CORE_02126], crbegin est en outre défini comme constexpr.

Utilisation

La méthode crend de la classe modèle ara::core::Map ([SWS_CORE_01451]) est disponible via l'en-tête ara/core/map.h. Elle renvoie de manière synchrone un itérateur inverse constant (const_reverse_iterator) qui, conformément au comportement standard de std::map, marque l'atteinte de la fin d'une itération vers l'arrière sur les éléments.

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

La fonction possède la spécification noexcept et est classée comme « exception safe » ([SWS_CORE_01451]). L'appel ne lève aucune exception et ne requiert aucune vérification de codes d'erreur.

Concurrence et contraintes

En tant que méthode qualifiée const, crend ne modifie pas l'instance de map sous-jacente. Des accès en lecture concurrents via plusieurs threads devraient donc être sûrs, tant que l'instance n'est pas modifiée en écriture simultanément (interprétation). Question Q-5593deafcef41be3 (ouverte)

Interaction

La signature et la sémantique s'intègrent dans les interfaces d'itérateurs uniformes de la bibliothèque ara::core. Des fonctions crend analogues existent pour :

• ara::core::Vector ([SWS_CORE_01343]) et ara::core::BasicString ([SWS_CORE_03050]), chacune avec une déclaration const noexcept identique, ainsi que
• les conteneurs et vues ara::core::Array ([SWS_CORE_01261]), ara::core::Span ([SWS_CORE_01979]) et ara::core::StringView ([SWS_CORE_02127]), qui sont en outre déclarés comme constexpr.

Utilisation de emplace dans ara::core::Map

La fonction membre template emplace de la classe ara::core::Map sert à construire et insérer directement une nouvelle paire clé-valeur dans la mémoire associative [SWS_CORE_01458]. La fonction est définie dans l'en-tête #include "ara/core/map.h" et reçoit les arguments du constructeur via le paquet de paramètres Args&&... args [SWS_CORE_01458]. Comme résultat, l'appel synchrone renvoie un std::pair<iterator, bool> [SWS_CORE_01458]. Interprétation : le renvoi à [map] devrait signifier que le comportement suit le conteneur standard C++ std::map, de sorte que l'itérateur référence l'élément et que la valeur booléenne signale si l'entrée a été nouvellement insérée. Question Q-fa496892c1e5e15d (ouverte)

Concernant le traitement des erreurs et la robustesse, emplace est expressément classé dans la spécification comme not exception safe [SWS_CORE_01458]. Si l'allocation de mémoire ou la construction de l'objet échoue, l'implémentation ne garantit aucune cohérence du conteneur. Aucun code d'erreur AUTOSAR spécifique ou message à DET ou DEM n'est prévu pour cette interface fondamentale.

Dans le module core, il existe des opérations emplace analogues pour d'autres types de données, qui possèdent toutefois des garanties différentes : alors que ara::core::Vector::emplace est également spécifié comme non sûr face aux exceptions [SWS_CORE_01366], les implémentations dans ara::core::Optional [SWS_CORE_01119] ainsi que ara::core::Variant [SWS_CORE_01661] offrent une sécurité conditionnelle face aux exceptions (conditionally exception safe).

Utilisation

La fonction membre template emplace_hint de la classe de conteneur ara::core::Map sert à insérer un nouvel élément en utilisant une position suggérée comme indication de recherche ([SWS_CORE_01459]). Elle est fournie via l'en-tête ara/core/map.h et accepte l'itérateur position ainsi qu'un pack de paramètres args pour le transfert ([SWS_CORE_01459]). Le fonctionnement correspond à l'utilisation dans [map] ([SWS_CORE_01459]). Vraisemblablement, les arguments transmis sont directement utilisés pour la construction sur place (in-place) de l'entrée, ce qui devrait permettre d'obtenir une insertion accélérée en cas de positionnement adéquat. Question Q-564dd9bab5c0293f (ouverte)

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

Concernant la tolérance aux pannes, l'opération est explicitement classée comme not exception safe ([SWS_CORE_01459]). Si une erreur survient pendant l'allocation mémoire ou la construction de la paire clé-valeur, aucune garantie quant à l'état du conteneur ne devrait s'appliquer. Question (ouverte) Aucun code d'erreur particulier ni message de diagnostic tel que DET ou DEM n'est défini pour cette interface ([SWS_CORE_01459]).

Concurrence et restrictions

La spécification ne formule aucune déclaration quant à la concurrence et aux contextes d'appel ([SWS_CORE_01459]). Interprétation : en tant qu'opération modifiant l'état sur ara::core::Map, emplace_hint requiert une synchronisation externe en cas d'accès simultané par plusieurs threads afin d'éviter les incohérences de données. Question Q-04b3ab58544ceba4 (ouverte)

Utilisation

La fonction membre synchrone equal_range de la classe ara::core::Map est fournie via l'en-tête #include "ara/core/map.h" [SWS_CORE_01506]. Elle prend une clé x de type const key_type & et renvoie une paire d'itérateurs modifiables (std::pair<iterator, iterator>) délimitant la plage de toutes les entrées correspondantes [SWS_CORE_01506]. Le comportement suit la sémantique habituelle de [map] [SWS_CORE_01506] ; comme Map possède généralement des clés uniques, la plage de résultats ne devrait comporter au plus qu'un seul élément (interprétation). Question Q-d26df1f3ac3b6232 (ouverte)

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

La spécification classe explicitement la fonction comme not exception safe [SWS_CORE_01506]. Aucun code d'erreur spécifique, valeur de retour pour le signalement d'erreur ou rapport au DET ou au DEM n'est défini. Si la clé recherchée n'est pas trouvée, les deux itérateurs de la paire devraient être identiques et pointer vers la position d'insertion potentielle (interprétation selon [map]). Question (ouverte)

Concurrence et restrictions

L'opération est non constante et retourne des itérateurs non constants [SWS_CORE_01506]. Comme aucun mécanisme de synchronisation n'est documenté, les accès simultanés en lecture ou en écriture à la même instance de ara::core::Map ne sont probablement pas sûrs du point de vue des threads (interprétation) et nécessitent une synchronisation externe. Question Q-3fb76368d9de336f (ouverte)

Interaction

Pour les accès en lecture sur des instances constantes, la surcharge avec des paires de const_iterator est disponible [SWS_CORE_01507]. De plus, il existe des variantes modèles pour des recherches hétérogènes avec un type de clé quelconque K, tant pour les appels non constants [SWS_CORE_01508] que pour les appels constants [SWS_CORE_01509].

Utilisation

La fonction membre equal_range de la classe ara::core::Map détermine sur une instance constante la plage de toutes les entrées qui correspondent à une clé prédéfinie [SWS_CORE_01507]. Elle prend le paramètre const key_type &x et renvoie un std::pair<const_iterator, const_iterator>, lequel représente les limites de la plage [SWS_CORE_01507]. La fonction est mise à disposition via le fichier d'en-tête ara/core/map.h et est exécutée de manière synchrone [SWS_CORE_01507]. La sémantique correspond à la spécification de [map] [SWS_CORE_01507] ; par conséquent, la plage renvoyée pour une map à clés uniques ne devrait couvrir au maximum qu'une seule entrée. Question Q-f2bdc3bf2c17948e (ouverte)

Gestion des erreurs et conditions limites

Concernant le comportement vis-à-vis des erreurs et des exceptions, la méthode est spécifiée comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_01507]. Aucun code d'erreur spécifique, message DET ou événement DEM n'est défini. La méthode étant déclarée comme const, elle ne modifie pas l'état de l'objet appelant.

Interaction

L'opération est intégrée dans une série de surcharges connexes au sein de ara::core::Map :

• Pour les instances non constantes, [SWS_CORE_01506] propose la même recherche, mais fournit des itérateurs modifiables.
• Via les fonctions template [SWS_CORE_01508] et [SWS_CORE_01509], la recherche peut également être effectuée avec des clés compatibles du type K pour des maps modifiables ainsi que constantes.

Utilisation et sémantique

La fonction membre template equal_range de la classe ara::core::Map ([SWS_CORE_01508]) est mise à disposition via l'en-tête ara/core/map.h. Elle sert à trouver la plage de tous les éléments dont la clé concorde avec la valeur transmise. Le comportement se conforme ici à l'utilisation correspondante dans [map] ([SWS_CORE_01508]). L'appel synchrone accepte un paramètre de clé x du type générique const K& et fournit comme valeur de retour un std::pair<iterator, iterator> ([SWS_CORE_01508]). Interprétation : grâce au type de paramètre générique K, la fonction devrait prendre en charge une consultation hétérogène, de sorte que des comparaisons soient possibles sans conversion préalable en key_type. Question Q-19f39bf5b68f9a3c (ouverte)

Gestion des erreurs et conditions limites

Selon la spécification, la fonction est classée comme non sûre vis-à-vis des exceptions (not exception safe) ([SWS_CORE_01508]). Aucun code d'erreur spécifique, aucune valeur de retour pour l'indication d'erreur ni aucun message à l'attention de DET ou DEM n'est prévu. La fonction n'étant pas qualifiée comme const, elle renvoie des itérateurs modifiables qui autorisent des accès en écriture aux valeurs contenues.

Interaction

La fonction membre fait partie d'un groupe de surcharges equal_range connexes au sein de ara::core::Map :

• [SWS_CORE_01506] : variante non constante pour clés directes de type const key_type&.
• [SWS_CORE_01507] : variante constante pour clés directes de type const key_type&, qui renvoie const_iterator.
• [SWS_CORE_01509] : surcharge template constante pour clés génériques de type const K&.

Utilisation

La fonction membre template equal_range de la classe ara::core::Map issue de l'en-tête ara/core/map.h détermine la plage d'éléments qui correspondent à une clé de recherche transmise x de type K [SWS_CORE_01509]. En tant que méthode constante, elle renvoie une paire de valeurs d'itérateurs constants std::pair<const_iterator, const_iterator> et ne modifie pas le conteneur sous-jacent [SWS_CORE_01509]. Conformément à la spécification, la sémantique suit l'utilisation correspondante dans [map] [SWS_CORE_01509]. Interprétation : le paramètre template K devrait permettre une recherche hétérogène de clés, de sorte qu'aucun objet temporaire du type de clé ne doive être construit. Question Q-7f7a93cef3cf7d8f (ouverte)

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

Concernant la sécurité vis-à-vis des exceptions, la fonction est expressément classée comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_01509]. Aucun code d'erreur spécifique ni retour d'information vers des interfaces de diagnostic ou d'erreur (telles que DET ou DEM) n'est prévu dans le périmètre de la spécification pour cette fonction [SWS_CORE_01509].

Interaction et surcharges

La fonction est en relation directe avec les autres variantes de equal_range dans ara::core::Map :

• La surcharge template non constante [SWS_CORE_01508], qui renvoie une paire d'itérateurs modifiables.
• Les surcharges non basées sur des patrons (templates) pour const key_type &x sous forme non constante [SWS_CORE_01506] ainsi que sous forme constante [SWS_CORE_01507].

La fonction erase de la classe ara::core::Map supprime de manière synchrone du conteneur l'élément référencé par le paramètre transmis position [SWS_CORE_01480]. La définition est incluse via l'en-tête <ara/core/map.h> [SWS_CORE_01480]. Comme valeur de retour, la fonction fournit un itérateur sur l'élément de la map succédant immédiatement à l'élément supprimé [SWS_CORE_01480]. La sémantique suit la spécification selon l'utilisation correspondante dans [map] [SWS_CORE_01480].

Concernant la gestion des erreurs, l'opération est classée comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_01480]. Aucun code d'erreur spécifique, canal de repli ou message d'erreur via DET ou DEM n'est spécifié pour cet appel [SWS_CORE_01480]. Le comportement s'alignant sur [map], l'itérateur transmis devrait être invalidé par l'opération de suppression, tandis que les itérateurs sur les éléments restants restent probablement intacts [SWS_CORE_01480]. En l'absence de validation, la transmission d'un itérateur invalide ou non déréférençable mène probablement à un comportement indéfini (Interprétation). Question Q-1a4a3eae317fc52e (ouverte)

Dans l'interaction au sein de ara::core::Map, il existe des surcharges alternatives : en plus de la suppression via un iterator modifiable, une surcharge est disponible pour const_iterator [SWS_CORE_01481]. De même, les éléments peuvent être supprimés par clé via key_type [SWS_CORE_01482] ou sous la forme d'une plage complète d'itérateurs [SWS_CORE_01483].

La fonction membre erase de la classe ara::core::Map sert à la suppression synchrone d'un élément individuel à l'emplacement indiqué par l'itérateur position [SWS_CORE_01481]. La déclaration s'effectue via le fichier d'en-tête ara/core/map.h [SWS_CORE_01481]. Le comportement correspond à la définition dans [map], la fonction renvoyant un iterator sur l'élément suivant de la map [SWS_CORE_01481].

Concernant la gestion des exceptions, la fonction est spécifiée comme « not exception safe » [SWS_CORE_01481]. Aucun code d'erreur, violation ou message d'erreur spécifique n'est défini pour cette opération [SWS_CORE_01481]. Interprétation : la transmission d'un itérateur non valide ou non déréférençable en tant que position devrait conduire à un comportement indéfini, car la spécification ne prévoit aucune vérification d'erreur. Question Q-9a3242ae4773cc0b (ouverte)

En interaction avec l'interface de conteneur de ara::core::Map, d'autres surcharges sont disponibles :

• Suppression via un itérateur modifiable iterator position [SWS_CORE_01480],
• Suppression à l'aide d'une clé via erase(const key_type &x) avec retour du nombre d'éléments supprimés [SWS_CORE_01482],
• Suppression de plage via deux itérateurs first et last [SWS_CORE_01483].

Des surcharges correspondantes pour des positions individuelles const_iterator sont définies de manière analogue pour d'autres conteneurs tels que ara::core::Vector [SWS_CORE_01372] ou ara::core::BasicString [SWS_CORE_03103].

Utilisation

La fonction membre synchrone erase de la classe ara::core::Map sert à supprimer des entrées via une clé spécifiée x de type const key_type& ([SWS_CORE_01482]). L'interface est incluse via l'en-tête ara/core/map.h. Le comportement fonctionnel est défini comme équivalent à l'utilisation dans [map] ([SWS_CORE_01482]). Interprétation : conformément à cette référence de la norme C++, la valeur de retour de type size_type devrait indiquer le nombre d'éléments supprimés avec succès du conteneur. Question Q-03637eb7e5efe502 (ouverte)

Gestion des erreurs et conditions limites

Dans la spécification, la fonction est classée comme not exception safe ([SWS_CORE_01482]). Aucun code de retour spécifique pour les situations d'erreur ni aucune voie de notification via DET ou DEM ne sont définis pour cet appel de conteneur. Interprétation : en raison de l'absence de sécurité vis-à-vis des exceptions, aucune garantie ne devrait s'appliquer à l'état du conteneur en cas d'erreur, raison pour laquelle l'appelant devrait veiller à la cohérence des données et à la validité des paramètres d'appel avant l'exécution. Question (ouverte)

Interaction

La méthode constitue le pendant basé sur les clés des opérations de suppression basées sur les itérateurs de ara::core::Map, qui nettoient des positions individuelles ([SWS_CORE_01480], [SWS_CORE_01481]) ou des plages fermées d'itérateurs ([SWS_CORE_01483]). Le modèle de fonctions erase normalisées se retrouve dans ara::core pour l'ensemble des conteneurs, par exemple pour ara::core::Vector ([SWS_CORE_01372]) ou pour ara::core::BasicString ([SWS_CORE_03102]).

Utilisation

La fonction membre erase du conteneur ara::core::Map sert à supprimer une plage de valeurs délimitée par deux itérateurs [SWS_CORE_01483]. Elle est définie dans l'en-tête #include "ara/core/map.h" et possède la signature iterator erase (const_iterator first, const_iterator last); [SWS_CORE_01483]. Sur le plan fonctionnel, le comportement suit la sémantique habituelle dans [map] [SWS_CORE_01483]. Comme valeur de retour, elle fournit un iterator pointant sur l'élément qui suit immédiatement la plage supprimée, ou la fin du conteneur [SWS_CORE_01483].

Traitement des erreurs et restrictions

L'opération est explicitement classée dans la spécification comme not exception safe [SWS_CORE_01483]. Aucun code d'erreur AUTOSAR spécifique ni message vers DET ou DEM n'est défini pour cette fonction. L'appelant devrait donc devoir s'assurer sous sa propre responsabilité que first et last référencent une plage valide et bien formée au sein de la même instance, car aucun contrôle distinct n'est prévu (Interprétation). Question Q-69e88ecc6f04bb64 (ouverte)

Interaction

Au sein de ara::core::Map, cette suppression de plage complète les surcharges destinées à supprimer des éléments individuels au moyen de iterator [SWS_CORE_01480], au moyen de const_iterator [SWS_CORE_01481] ainsi qu'à l'aide d'une clé key_type [SWS_CORE_01482]. Des interfaces erase similaires pour les plages d'itérateurs se trouvent également dans d'autres conteneurs de l'Adaptive Core Library, notamment dans ara::core::Vector [SWS_CORE_01373] et ara::core::BasicString [SWS_CORE_03104].

La fonction membre extract de la classe ara::core::Map extrait l'élément situé à l'emplacement désigné par l'itérateur position et renvoie un nœud de type node_type [SWS_CORE_01470]. La déclaration et la sémantique suivent ici l'utilisation correspondante dans [map], ce qui détache directement le nœud du conteneur associatif. La fonction est mise à disposition via l'en-tête ara/core/map.h.

Utilisation et comportement

L'appel s'effectue de manière synchrone sur une instance de ara::core::Map. Un const_iterator position est transmis en tant que paramètre, lequel doit Interprétation : pointer vers un élément valide et déréférençable au sein de la map appelée. Du fait de l'extraction, l'élément est retiré du conteneur, tandis que l'objet node_type renvoyé prend la propriété du nœud.

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

Concernant le traitement des exceptions, la fonction est expressément classée comme not exception safe selon la spécification [SWS_CORE_01470]. Si une exception se produit pendant l'exécution, l'opération ne garantit aucun état déterministe pour le conteneur, raison pour laquelle le code appelant devrait prévoir des protections appropriées.

Interaction et alternatives

En plus de l'extraction basée sur la position, la variante extract(const key_type &x) basée sur une clé est également disponible sous forme de surcharge [SWS_CORE_01471]. Cette dernière permet d'extraire une entrée directement à l'aide de sa valeur de clé, sans avoir à déterminer manuellement un itérateur au préalable.

Utilisation

La fonction membre synchrone extract est définie dans le fichier d'en-tête #include "ara/core/map.h" au sein de la classe ara::core::Map [SWS_CORE_01471]. Elle prend comme paramètre une référence de clé constante const key_type &x et renvoie l'élément trouvé sous la forme node_type [SWS_CORE_01471]. La sémantique fonctionnelle renvoie à l'utilisation correspondante dans [map] [SWS_CORE_01471] ; cela devrait correspondre au standard C++, selon lequel le nœud est directement extrait du conteneur sans qu'il soit nécessaire de copier la clé ou la valeur. Question (ouverte)

Traitement des erreurs et restrictions

La fonction est explicitement classée dans la spécification comme « not exception safe » [SWS_CORE_01471]. Aucun code d'erreur spécifique, classe d'erreur ou message DET ou DEM n'est défini dans le payload. En cas d'erreur, aucune garantie ne devrait donc exister quant au maintien ou à la cohérence de l'état du conteneur, raison pour laquelle les points appelants devraient prévoir des mesures de protection appropriées. Question (ouverte)

Interaction

L'élément de spécification est directement lié à la surcharge node_type extract(const_iterator position) [SWS_CORE_01470]. Tandis que la présente fonction identifie et extrait un élément via la clé de recherche [SWS_CORE_01471], la variante apparentée permet le retrait ciblé via une position d'itérateur déjà connue [SWS_CORE_01470]. Les deux interfaces appartiennent à la portée de ara::core::Map et partagent la même propriété d'absence de sécurité face aux exceptions [SWS_CORE_01470] [SWS_CORE_01471].

Utilisation

La fonction membre find de la classe ara::core::Map sert à trouver de manière synchrone un élément à partir de sa clé [SWS_CORE_01490]. La fonction est déclarée dans le fichier d'en-tête ara/core/map.h. Elle accepte une référence sur la clé recherchée (const key_type &x) et renvoie un iterator modifiable sur la paire clé-valeur trouvée ; si aucune entrée correspondante n'est trouvée, la valeur de retour correspond à l'itérateur de fin de la map [SWS_CORE_01490].

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

Conformément à la spécification, cette fonction est classée comme not exception safe [SWS_CORE_01490]. Aucun message d'erreur via DET ou DEM n'est spécifié pour ce service de base de conteneur. Si des erreurs opérationnelles surviennent pendant la comparaison, des exceptions de l'opérateur de comparaison sous-jacent peuvent être propagées.

Concurrence et interaction

Puisqu'il s'agit d'une fonction membre non constante fournissant un itérateur accessible en écriture, un accès concurrent sans synchronisation n'est probablement pas thread-safe. Question Q-0f9f56b506cfd318 (ouverte) Pour l'accès en lecture seule sur des instances constantes de ara::core::Map, la surcharge avec const_iterator est disponible [SWS_CORE_01491]. De plus, des surcharges sous forme de modèles prennent en charge une recherche transparente avec des types de comparaison compatibles K, aussi bien modifiante [SWS_CORE_01492] que constante [SWS_CORE_01493]. Contrairement aux fonctions find basées sur des caractères dans ara::core::StringView [SWS_CORE_02157] ou ara::core::BasicString [SWS_CORE_03315], qui fournissent des indices de type size_type et sont en partie noexcept, cette fonction opère sur des conteneurs via des itérateurs.

La fonction membre constante find de la classe ara::core::Map sert à trouver de manière synchrone une entrée à l'aide de sa clé [SWS_CORE_01491]. Pour l'appel, l'en-tête #include "ara/core/map.h" doit être inclus. En guise de paramètre, la fonction attend une référence sur la clé recherchée const key_type &x. Le comportement correspond à la spécification de [map] dans le standard C++, de sorte qu'en cas de recherche fructueuse, un const_iterator sur l'élément est renvoyé et que, dans le cas contraire, end() est vraisemblablement fourni [SWS_CORE_01491]. Question Q-dca69a1ec5423a8b (ouverte)

Concernant le traitement des erreurs, la fonction est déclarée comme not exception safe [SWS_CORE_01491]. Étant donné que le processus de recherche repose sur la comparaison de clés, les exceptions survenant devraient résulter principalement de l'opération de comparaison définie par l'utilisateur. Aucun message d'erreur DET ou DEM n'est défini pour ce conteneur élémentaire. Puisqu'il s'agit d'une opération de lecture sur une instance constante, l'accès concurrent de plusieurs threads au même objet peut être parallélisé selon la sémantique usuelle des conteneurs C++, tant qu'aucune modification simultanée n'a lieu (interprétation). Question Q-a8ec748711885418 (ouverte)

En interaction avec d'autres interfaces, la méthode complète la variante non constante [SWS_CORE_01490], laquelle fournit un iterator modifiable. Pour des opérations de recherche hétérogènes sans conversion de type, des surcharges template pour instances modifiables [SWS_CORE_01492] ainsi que pour instances constantes [SWS_CORE_01493] sont en outre disponibles dans ara::core::Map. Des fonctions de recherche de même nom existent par ailleurs dans le module Core pour des classes de chaînes de caractères telles que ara::core::BasicString [SWS_CORE_03407] et ara::core::StringView [SWS_CORE_02157].

La fonction membre template find selon [SWS_CORE_01492] sert à trouver de manière synchrone un élément au sein d'une instance de ara::core::Map via le fichier d'en-tête ara/core/map.h. Elle accepte un paramètre de référence const K &x et renvoie un iterator modifiable sur la paire clé-valeur trouvée ou l'itérateur de fin du conteneur. La spécification renvoie au comportement de [map] ; la forme de paramètre générique devrait ici être interprétée comme une recherche de clé hétérogène, afin de comparer des clés de recherche de type différent sans conversion préalable. Question Q-425357890b9ea3fe (ouverte)

Concernant le traitement des erreurs et la sécurité vis-à-vis des exceptions, la fonction est explicitement classée comme not exception safe ([SWS_CORE_01492]). Aucun code d'erreur spécifique, aucune valeur de retour pour les états d'erreur ni aucun message DET/DEM n'est défini dans la charge utile. Si une exception survient lors de la comparaison ou du parcours interne, l'appel n'offre aucune garantie de sécurité d'exception.

Dans le cadre de l'interaction au sein de ara::core::Map, la fonction constitue le pendant non constant de la recherche hétérogène constante [SWS_CORE_01493] ainsi que des surcharges non génériques [SWS_CORE_01490] et [SWS_CORE_01491], qui sont chacune liées de manière fixe à const key_type &x. Elle se distingue fondamentalement des fonctions de recherche homonymes d'autres conteneurs tels que ara::core::StringView ([SWS_CORE_02157]) ou ara::core::BasicString ([SWS_CORE_03315]), qui effectuent des recherches de position basées sur des chaînes de caractères et sont en partie déclarées comme noexcept.

Utilisation

La fonction membre template find dans l'espace de noms ara::core::Map sert à trouver des éléments en lecture seule au moyen d'une clé x de type K [SWS_CORE_01493]. La fonction est définie dans l'en-tête #include "ara/core/map.h" et est appelée de manière synchrone sur une instance constante [SWS_CORE_01493]. Elle renvoie un const_iterator sur l'élément trouvé ; interprétation : en cas de clé inexistante, l'itérateur renvoyé devrait correspondre à l'itérateur de fin de la map, car la sémantique suit selon la spécification le comportement de [map] [SWS_CORE_01493]. Question Q-3fa354022f0bca9b (ouverte)

Gestion des erreurs et conditions limites

Concernant la tolérance aux pannes, la fonction est explicitement classée comme not exception safe [SWS_CORE_01493]. Aucun code d'erreur spécifique, aucune valeur de retour pour l'indication d'erreur ni aucun message à l'attention de DET ou DEM n'est défini dans la spécification. Les appelants doivent tenir compte du fait qu'en cas d'exceptions survenant pendant l'opération de recherche ou de comparaison, aucune garantie quant à la sécurité des exceptions n'est fournie [SWS_CORE_01493].

Interaction

Au sein de ara::core::Map, cette surcharge complète les opérations de recherche :

• Elle complète la variante template non constante iterator find(const K &x) [SWS_CORE_01492].
• Elle constitue le pendant générique des surcharges avec const key_type &x fixe, lesquelles sont déclarées comme non constante [SWS_CORE_01490] ainsi que constante [SWS_CORE_01491].

Elle se distingue ainsi des opérations homonymes dans ara::core::StringView (par ex. [SWS_CORE_02157]) et ara::core::BasicString (par ex. [SWS_CORE_03315]), qui opèrent sur des chaînes de caractères, fournissent des positions de type size_type et sont déclarées comme exception safe.

Utilisation

La fonction insert dans le contexte de ara::core::Map sert à ajouter de manière synchrone un élément de valeur par copie via le paramètre const value_type &x ([SWS_CORE_01460]). L'opération est incluse via le fichier d'en-tête ara/core/map.h. Le type de retour std::pair<iterator, bool> suit la spécification « As per corresponding usage in [map] » : Interprétation : l'itérateur devrait ici pointer vers l'élément nouvellement inséré ou déjà existant, tandis que le drapeau booléen signale le succès de la nouvelle insertion. Question Q-b059c1d0f4dd6665 (ouverte)

Gestion des erreurs

Aucun code d'erreur AUTOSAR spécifique tel que des messages DET ou DEM n'est prévu dans la spécification. La fonction est expressément déclarée comme non sûre vis-à-vis des exceptions (« not exception safe ») ([SWS_CORE_01460]). En cas d'échec d'une allocation de mémoire interne ou de la copie de l'élément, le conteneur n'offre aucune garantie d'exception ou de rollback ; une telle erreur devrait vraisemblablement conduire à une interruption ou à un état indéfini. Question Q-cbe74b301167bcc4 (ouverte)

Concurrence et restrictions

L'appel s'effectue de manière synchrone dans le thread de l'appelant. Les opérations du conteneur ne disposent d'aucune synchronisation intégrée, c'est pourquoi la fonction n'est pas réentrante pour une même instance. Les accès concurrents en lecture ou en écriture doivent être protégés du côté de l'appelant.

Interaction

Il existe des surcharges complémentaires de insert pour ara::core::Map :

• Variantes basées sur le déplacement (move) pour les valeurs temporaires ([SWS_CORE_01461], [SWS_CORE_01462]),
• Opérations d'insertion positionnelles avec indication d'itérateur (hint) ([SWS_CORE_01463], [SWS_CORE_01464]),
• Listes d'intervalles et d'initialisation ([SWS_CORE_01466], [SWS_CORE_01467]) ainsi que transferts de node handles ([SWS_CORE_01468], [SWS_CORE_01469]).

Des opérations d'insertion analogues se trouvent, avec des signatures adaptées, dans d'autres classes Core telles que ara::core::Vector ([SWS_CORE_01367]) et ara::core::BasicString ([SWS_CORE_03093]).

La fonction membre insert de ara::core::Map insère de manière synchrone un élément dans le conteneur associatif au moyen de la sémantique de déplacement via une référence rvalue (value_type &&x) ([SWS_CORE_01461]). La déclaration s'effectue via le fichier d'en-tête #include "ara/core/map.h" ([SWS_CORE_01461]). Conformément à la spécification, le comportement fonctionnel suit l'utilisation correspondante dans [map] du standard C++ ([SWS_CORE_01461]). Comme valeur de retour, la fonction fournit un std::pair<iterator, bool> ; Interprétation : ici, la valeur booléenne devrait signaler si l'élément a été nouvellement inséré, tandis que l'itérateur référence l'élément dans le conteneur ([SWS_CORE_01461]). Question Q-e1901e26d8be3470 (ouverte)

En ce qui concerne le traitement des erreurs et la sécurité vis-à-vis des exceptions, la fonction est explicitement classée dans la spécification comme not exception safe ([SWS_CORE_01461]). Aucun code d'erreur spécifique ni message d'erreur AUTOSAR tel que DET ou DEM n'est spécifié pour cet appel.

Dans le cadre de l'interaction au sein de ara::core::Map, cette surcharge représente le pendant basé sur les rvalues de la variante par copie insert(const value_type &) ([SWS_CORE_01460]) et de la version de modèle générique insert(P &&) ([SWS_CORE_01462]). Pour les opérations d'insertion avec indication de position, des surcharges avec itérateur d'indication (hint) telles que insert(const_iterator, value_type &&) ([SWS_CORE_01464]) ainsi que pour les gestionnaires de nœuds (node handles) via insert(node_type &&) ([SWS_CORE_01468]) en utilisant insert_return_type ([SWS_CORE_01418]) sont également disponibles.

La fonction membre template insert de la classe ara::core::Map sert à insérer de manière synchrone une paire clé-valeur compatible via une référence de transfert P&& x dans l’instance de conteneur associatif [SWS_CORE_01462]. Elle est incluse via l’en-tête #include "ara/core/map.h" et renvoie pour son comportement à la sémantique de [map] [SWS_CORE_01462]. Comme valeur de retour, elle fournit un std::pair<iterator, bool> [SWS_CORE_01462]. Interprétation : la valeur de retour booléenne devrait indiquer si une nouvelle entrée a été créée, tandis que l’itérateur pointe vers l’élément nouvellement inséré ou déjà existant. Question Q-64d2947d60792374 (ouverte)

En ce qui concerne le traitement des erreurs, la fonction est expressément classée dans la spécification comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_01462]. Aucun code d’erreur spécifique, message d’erreur ou interface vers des mémoires de diagnostic et d’erreurs comme DET ou DEM n’est spécifié pour cet appel.

Concernant la concurrence et les conditions aux limites, l’appel modifie l’état de la map ; par conséquent, l’accès simultané à la même instance n’est probablement pas réentrant et exige une protection externe contre les courses de données. Question (ouverte) L’exécution a lieu de manière synchrone dans le contexte du thread appelant.

Dans l’interaction au sein de ara::core::Map, cette fonction générique constitue un complément aux surcharges directes pour const value_type& [SWS_CORE_01460] et value_type&& [SWS_CORE_01461]. De plus, il existe des opérations d’insertion basées sur la position avec indication d’itérateur [SWS_CORE_01465], des opérations de plage [SWS_CORE_01466] ainsi que l’insertion de poignées de nœuds (node handles) au moyen de insert_return_type [SWS_CORE_01418] [SWS_CORE_01468].