classe ara::core::Vector

Utilisation et contexte d'appel

La fonction membre modèle assign pour ara::core::Vector remplace le contenu actuel du vecteur par les éléments de la plage [first, last) conformément à l'usage correspondant dans std::vector [SWS_CORE_01328]. La fonction est définie dans le fichier d'en-tête #include "ara/core/vector.h", accepte deux itérateurs d'entrée et ne renvoie aucune valeur (void) [SWS_CORE_01328].

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

La fonction d'affectation est classée comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_01328]. Si une exception survient pendant le traitement des éléments ou lors d'allocations de mémoire internes nécessaires, le conteneur reste potentiellement dans un état incomplet sans garanties de sécurité définies.

Concurrence et contraintes

Pour des appels concurrents lors de l'utilisation simultanée de la même instance de ara::core::Vector, une synchronisation externe devrait être nécessaire, car la spécification ne garantit pas la sécurité des threads. Question Q-5ada879738b3856d (ouverte) De plus, une condition préalable au déroulement sans erreur est que first et last définissent une plage d'itérateurs valide.

Interaction dans le module core

Outre l'affectation de plage via des itérateurs, ara::core::Vector met à disposition des surcharges avec nombre et valeur de référence [SWS_CORE_01329] ainsi que pour std::initializer_list<T> [SWS_CORE_01330], qui sont également déclarées comme non sûres vis-à-vis des exceptions. Des motifs d'affectation comparables existent également dans le contexte de module de ara::core::BasicString [SWS_CORE_03091].

Utilisation

La fonction assign appartient à la classe de conteneur ara::core::Vector et est fournie via le fichier d'en-tête #include "ara/core/vector.h" [SWS_CORE_01329]. Avec la signature void assign (size_type n, const T &u);, elle remplace complètement le contenu actuel du vecteur par n éléments ayant la valeur u. L'appel s'effectue de manière synchrone et ne renvoie aucune valeur (void). Conformément à la spécification, le comportement suit l'utilisation correspondante dans le conteneur standard [vector] [SWS_CORE_01329], ce qui désigne probablement la sémantique de std::vector::assign. Question Q-3630162224047ee0 (ouverte)

Gestion des erreurs

En ce qui concerne la robustesse, la fonction est explicitement classée comme not exception safe [SWS_CORE_01329]. Aucun code d'erreur, classe d'erreur ou message vers DET ou DEM spécifique à AUTOSAR n'est défini. Si une exception se produit pendant l'allocation de mémoire ou lors de l'assignation des éléments, la fonction n'offre probablement aucune garantie quant à la restauration de l'état initial de l'objet. Question Q-f4eb9afa74847bf7 (ouverte)

Concurrence et restrictions

Comme assign modifie l’état et potentiellement la capacité de l’instance de conteneur, l’appel n’est pas réentrant sur la même instance. En l’absence d’engagements spécifiques relatifs à la sécurité des threads dans la spécification, un accès simultané en lecture ou en écriture au même objet Vector sans synchronisation externe ne devrait pas être thread-safe. Question Q-1df95afd2340ec57 (ouverte)

Interaction

Avec d’autres surcharges de la classe ara::core::Vector, la fonction constitue l’interface de réassignation du contenu du vecteur :

• Assignation basée sur les itérateurs sur une plage assign(InputIterator first, InputIterator last) conformément à [SWS_CORE_01328].
• Assignation via une liste d’initialisation assign(std::initializer_list<T>) conformément à [SWS_CORE_01330].

Les deux surcharges alternatives partagent avec [SWS_CORE_01329] la propriété d’être spécifiées comme not exception safe.

La fonction membre assign de la classe ara::core::Vector remplace de manière synchrone l’intégralité du contenu antérieur d’une instance de vecteur par les éléments de la liste d’initialisation std::initializer_list<T> fournie ([SWS_CORE_01330]). Le comportement fonctionnel suit l’utilisation correspondante du conteneur standard dans [vector] ([SWS_CORE_01330]). La fonction n’a pas de valeur de retour (void) et est déclarée via l’en-tête ara/core/vector.h ([SWS_CORE_01330]).

Pour la gestion des erreurs, il est défini que la méthode est classée comme not exception safe ([SWS_CORE_01330]). Interprétation : si une exception survient pendant l’allocation de mémoire ou lors de la copie ou du déplacement des éléments, l’implémentation n’offre probablement pas de sécurité forte vis-à-vis des exceptions ; le vecteur devrait demeurer dans un état modifié ou incomplet. Question Q-ac196ecfba85d821 (ouverte)

En combinaison avec d’autres interfaces de ara::core::Vector, la fonction complète des surcharges d’assignation alternatives telles que l’initialisation via des plages d’itérateurs ([SWS_CORE_01328]) et l’assignation répétée d’une valeur unique ([SWS_CORE_01329]). Toutes ces variantes de assign partagent la propriété de ne pas être sûres au regard des exceptions. Une sémantique d’assignation comparable au moyen de std::initializer_list se trouve également au sein de la bibliothèque centrale pour ara::core::BasicString ([SWS_CORE_03092]).

Utilisation et sémantique

La fonction membre at fournit un accès synchrone en lecture à un élément du conteneur ara::core::Vector à l'indice spécifié n et renvoie une const_reference sur l'élément [SWS_CORE_01354]. La déclaration est disponible via l'en-tête ara/core/vector.h [SWS_CORE_01354]. La sémantique correspond à la fonction standard std::vector::at issue du standard C++, mais diffère sur le traitement des erreurs [SWS_CORE_01354].

Gestion des erreurs et conditions limites

Si un indice atteignant ou dépassant la taille du conteneur est demandé (n >= size()), une IsoStdOutOfRangeViolation est déclenchée au lieu de l'exception standard std::out_of_range [SWS_CORE_01354]. La fonction est déclarée comme not exception safe [SWS_CORE_01354]. Interprétation : aucune exception C++ n'étant levée, le déclenchement de la violation devrait probablement conduire à une interruption du flux du programme, pouvant potentiellement interagir avec des mécanismes de traitement tels que AddAbortHandler [SWS_CORE_00054]. Question Q-2182d648ff4a28b8 (ouverte)

Interaction au sein du module

Pour les accès modificateurs, la surcharge non constante avec le retour reference est disponible, qui suit le même chemin d'erreur [SWS_CORE_01355]. Le comportement divergent identique avec IsoStdOutOfRangeViolation se retrouve également dans d'autres types de données du Core tels que ara::core::Array [SWS_CORE_01273] [SWS_CORE_01274] et ara::core::BasicString [SWS_CORE_03063].

La fonction membre at de la classe ara::core::Vector ([SWS_CORE_01355]), fournie via l'en-tête #include "ara/core/vector.h", permet l'accès indexé en lecture et en écriture aux différents éléments d'un vecteur. La fonction accepte un indice de position n de type size_type et renvoie une référence modifiable (reference) sur l'élément à la position indiquée. La sémantique suit l'implémentation correspondante dans [vector]. Interprétation : comme l'interface est déclarée de manière synchrone selon le standard C++, l'exécution devrait s'effectuer de manière bloquante directement dans le contexte du thread appelant. Question Q-81f43622c244ce91 (ouverte)

À la différence du vecteur standard ISO C++, la fonction déclenche, en cas de dépassement d'indice (n >= size()), la violation IsoStdOutOfRangeViolation au lieu de l'exception standard std::out_of_range ([SWS_CORE_01355]). Dans la spécification, la fonction est classée comme non sûre vis-à-vis des exceptions (not exception safe) ([SWS_CORE_01355]). Interprétation : comme aucun mécanisme de synchronisation n'est spécifié pour cet accès au vecteur, un accès concurrent non protégé à la même instance ne devrait pas être thread-safe. Question Q-e65ae0c574610719 (ouverte)

Pour l'accès constant en lecture seule, la surcharge const_reference at(size_type n) const est disponible, laquelle signale également IsoStdOutOfRangeViolation et est considérée comme non sûre vis-à-vis des exceptions ([SWS_CORE_01354]). Des conteneurs et types associés de la bibliothèque principale utilisent également la même sémantique de violation en cas d'accès erroné, parmi lesquels ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), ara::core::StringView ([SWS_CORE_02133]) ainsi que ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).

Utilisation et sémantique

La méthode clear() de la classe ara::core::Vector sert à vider entièrement le vecteur conformément à [SWS_CORE_01375]. La fonction est déclarée dans l'en-tête ara/core/vector.h, peut être appelée de manière synchrone, ne prend aucun paramètre et ne renvoie aucune valeur (void). Sa sémantique fonctionnelle s'aligne sur la spécification correspondante pour [vector]. Interprétation : cela devrait signifier que tous les éléments présents dans le vecteur sont détruits et que le nombre d'éléments tombe à 0, tandis que la capacité mémoire allouée devrait rester inchangée. Question Q-ecde315e61455c32 (ouverte)

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

L'appel est caractérisé par noexcept ainsi que classé comme sûr vis-à-vis des exceptions (exception safe) conformément à [SWS_CORE_01375]. Comme la méthode ne lève assurément aucune exception, aucun code d'erreur spécifique n'existe et aucun message d'erreur DET ou DEM n'est émis en cas d'erreur.

Interaction avec les conteneurs apparentés

Le concept d'une fonction clear() sûre vis-à-vis des exceptions est étendu de manière cohérente à d'autres structures de données dans ara::core. Ainsi, ara::core::Map fournit dans l'en-tête ara/core/map.h une méthode clear() identique conformément à [map] [SWS_CORE_01485]. De même, ara::core::BasicString propose dans l'en-tête ara/core/string.h une opération clear() équivalente conformément à [basic.string] [SWS_CORE_03057].

La fonction membre crbegin de ara::core::Vector fournit, conformément à [SWS_CORE_01342], un itérateur inverse constant (const_reverse_iterator) sur le dernier élément de la séquence. L’appel s’effectue de manière synchrone et sans paramètre via l’en-tête ara/core/vector.h. Le comportement correspond à la spécification de la bibliothèque standard C++ sous-jacente pour [vector]. Pour un conteneur vide, l’itérateur renvoyé devrait correspondre à la valeur de crend() (interprétation basée sur [vector]). Question Q-a2badba87f86486c (ouverte)

En ce qui concerne le traitement des erreurs, l’interface est pourvue de l’identifiant noexcept et déclarée sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_01342]). Les appels ne lèvent aucune exception et ne signalent aucune erreur aux surveillances d’exécution ou de diagnostic.

Concernant la concurrence et les restrictions, la méthode est qualifiée de const. L’accès simultané en lecture à la même instance à partir de plusieurs threads devrait être réentrant et sûr pour les threads tant qu’aucune opération d’écriture concurrente n’est exécutée sur le vecteur (interprétation analogue au modèle de conteneur C++). Question Q-094ba5878c1adc74 (ouverte)

Dans le module core, le concept d’itération inverse constante est implémenté de manière cohérente sur divers types. Des interfaces similaires se trouvent pour ara::core::Array ([SWS_CORE_01260]), ara::core::Map ([SWS_CORE_01450]), ara::core::Span ([SWS_CORE_01978]), ara::core::StringView ([SWS_CORE_02126]) ainsi que ara::core::BasicString ([SWS_CORE_03049]).

La fonction membre crend de la classe ara::core::Vector fournit un itérateur inverse constant qui pointe vers l’élément théorique précédant le premier élément du vecteur [SWS_CORE_01343]. La sémantique suit l’utilisation correspondante dans le standard C++ pour std::vector (« As per corresponding usage in [vector] ») [SWS_CORE_01343].

Utilisation et comportement

• Contexte d’appel et paramètres : la méthode est sans paramètre et déclarée comme const, de sorte qu’elle peut être appelée de manière synchrone sur des instances constantes comme non constantes de ara::core::Vector [SWS_CORE_01343].
• Valeur de retour : un const_reverse_iterator est renvoyé, marquant la fin logique d’une itération vers l’arrière [SWS_CORE_01343].

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

La fonction est spécifiée avec noexcept et est considérée comme sûre vis-à-vis des exceptions (« exception safe ») selon la spécification [SWS_CORE_01343]. Aucun code d’erreur spécifique n’est renvoyé et aucune exception ne se produit.

Interaction avec les conteneurs apparentés

Le concept d’un itérateur inverse constant vers le point final d’une itération inverse est fourni de manière uniforme dans l’ensemble des conteneurs de ara::core. Des interfaces similaires présentant un traitement des exceptions identique (noexcept) existent notamment pour ara::core::Array [SWS_CORE_01261], ara::core::Map [SWS_CORE_01451], ara::core::Span [SWS_CORE_01979], ara::core::StringView [SWS_CORE_02127] ainsi que ara::core::BasicString [SWS_CORE_03050].

La fonction emplace insère un élément directement à la position spécifiée dans un ara::core::Vector en transférant les arguments transmis [SWS_CORE_01366]. La déclaration se trouve dans l'en-tête #include "ara/core/vector.h" et suit l'utilisation correspondante dans [vector] [SWS_CORE_01366].

Utilisation

L'appel de emplace s'effectue de manière synchrone et prend comme paramètres un itérateur de position position de type const_iterator ainsi qu'un paquet de paramètres args de type Args&&... [SWS_CORE_01366]. Comme valeur de retour, la fonction fournit un iterator sur l'élément nouvellement construit [SWS_CORE_01366].

Gestion des erreurs et concurrence

Pour emplace dans ara::core::Vector, la sécurité face aux exceptions est explicitement spécifiée comme not exception safe [SWS_CORE_01366]. Aucun code d'erreur spécifique, message DET ou DEM n'est défini dans le standard. Interprétation : en l'absence de mécanismes de synchronisation internes, l'appel concurrent de emplace sur la même instance ne devrait pas être sûr pour les threads sans protection externe. Question Q-d72278df37e86c8a (ouverte)

Interaction

Au sein de ara::core, la sécurité face aux exceptions pour emplace varie selon le type :

• Dans ara::core::Map, emplace est également défini comme not exception safe, mais renvoie std::pair<iterator, bool> [SWS_CORE_01458].
• Dans ara::core::Optional, les variantes sont conditionnellement sûres face aux exceptions ([SWS_CORE_01119], [SWS_CORE_01120]) ou, pour les références, totalement sûres face aux exceptions [SWS_CORE_01164].
• Dans ara::core::Variant, emplace est déclaré comme conditionally exception safe avec noexcept ([SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664]).

Utilisation

La méthode template emplace_back de la classe ara::core::Vector sert, conformément à [SWS_CORE_01362], à construire un nouvel élément directement à la fin du vecteur. Les paramètres de transmission Args&&... args sont alors directement transmis au constructeur du type d'élément selon la sémantique de [vector]. En tant que valeur de retour, la fonction renvoie une référence (reference) vers l'élément nouvellement créé. Pour l'utilisation, l'en-tête #include "ara/core/vector.h" doit être inclus [SWS_CORE_01362].

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

En ce qui concerne la sécurité vis-à-vis des exceptions, l'opération est explicitement déclarée dans [SWS_CORE_01362] comme not exception safe. Aucun code d'erreur spécifique, aucune valeur de repli ni aucun message adressé à des services d'erreur tels que DET ou DEM ne sont définis dans la spécification.

Restrictions et comportement

En raison de la propriété not exception safe et de l'orientation d'après [vector], aucune garantie ne devrait exister en cas d'erreur, par exemple lors d'une allocation de mémoire ou d'une construction infructueuse, quant à la préservation de l'état antérieur du conteneur (interprétation). Question Q-ca44b2f27d8ae1c8 (ouverte) Les appelants doivent donc s'assurer d'éviter au préalable les conditions d'erreur potentielles.

La fonction erase de la classe ara::core::Vector sert, conformément à [SWS_CORE_01372], à supprimer de manière synchrone un élément individuel à l’emplacement désigné par le paramètre position (const_iterator). Comme valeur de retour, elle fournit un iterator sur l’élément suivant ou sur la fin du conteneur si l’élément supprimé se trouvait en dernière position, conformément à la sémantique référencée dans [vector]. La fonction est déclarée dans le fichier d’en-tête #include "ara/core/vector.h".

En ce qui concerne le traitement des erreurs, l’opération est expressément indiquée dans la spécification comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_01372]. Aucun retour d’erreur spécifique, message DET ou DEM n’est défini ; des itérateurs invalides ou non déréférençables devraient donc conduire à un comportement indéfini. Question Q-efa4c40e48a6f98d (ouverte) En raison du déplacement des éléments dans le vecteur, il convient de supposer, en tant qu’interprétation :, que les itérateurs et références suivants deviennent invalides, conformément à la sémantique standard de [vector].

Dans l’interaction au sein de ara::core::Vector, il existe en plus de la suppression à une position individuelle la surcharge erase(first, last) pour des plages entières conformément à [SWS_CORE_01373]. Des interfaces analogues pour la suppression d’entrées se trouvent dans d’autres conteneurs de la bibliothèque Adaptive Core : ara::core::Map fournit des surcharges basées sur la position et sur les clés ([SWS_CORE_01480], [SWS_CORE_01481], [SWS_CORE_01482], [SWS_CORE_01483]), tandis que ara::core::BasicString comprend des variantes basées sur les indices et les itérateurs ([SWS_CORE_03102], [SWS_CORE_03103], [SWS_CORE_03104]).

La fonction membre erase de la classe ara::core::Vector sert à supprimer une plage d’éléments du vecteur conformément à la spécification [SWS_CORE_01373]. La déclaration est disponible via l’en-tête ara/core/vector.h. La sémantique suit l’utilisation correspondante dans le vecteur standard (« As per corresponding usage in [vector] »). Deux itérateurs first et last délimitant la plage à supprimer sont passés en paramètres ; un iterator sur l’élément suivant est renvoyé.

En ce qui concerne le traitement des erreurs et la sécurité vis-à-vis des exceptions, l’opération est explicitement classifiée comme « not exception safe » dans la spécification [SWS_CORE_01373]. Contrairement à d’autres opérations de conteneur, aucun code d’erreur spécifique ni violation d’erreur (violations) n’est défini pour cette fonction. Si une erreur survient lors de l’exécution, cela laisse probablement le conteneur dans un état incohérent. Question (ouverte)

Concernant la concurrence et les restrictions, la spécification est silencieuse ; les opérations modifiant ara::core::Vector ne devraient toutefois pas être réentrantes et requièrent vraisemblablement une protection externe en mode multi-thread. Question Q-07fc291a523a82f1 (ouverte)

Dans l’interaction avec d’autres interfaces du module Core, cette fonction complète la surcharge de suppression d’un élément individuel à une position donnée au moyen de iterator erase(const_iterator position) [SWS_CORE_01372]. Des suppressions de plage correspondantes selon le même schéma sont également définies pour les conteneurs associatifs tels que ara::core::Map via [SWS_CORE_01483] ainsi que les chaînes de caractères dans ara::core::BasicString via [SWS_CORE_03104].

Utilisation

La fonction membre insert de la classe ara::core::Vector sert à insérer de manière synchrone un élément à une position donnée [SWS_CORE_01367]. Elle est définie dans l'en-tête #include "ara/core/vector.h" [SWS_CORE_01367]. La fonction prend comme paramètres un itérateur position de type const_iterator marquant la position cible, ainsi qu'une référence constante x vers l'objet à insérer de type const T & [SWS_CORE_01367]. La valeur de retour est un iterator qui pointe vers l'élément nouvellement inséré [SWS_CORE_01367]. Le comportement fonctionnel suit ici l'utilisation dans le vecteur standard (« As per corresponding usage in [vector] ») [SWS_CORE_01367].

Traitement des erreurs et restrictions

La spécification classe expressément la fonction comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_01367]. Aucun code d'erreur spécifique, aucune valeur de retour pour les cas d'erreur ni aucun message à DET ou DEM n'est défini. Interprétation : en cas d'échec d'une allocation de mémoire interne ou de la copie de l'élément, aucune garantie ne devrait exister quant à la préservation de l'état du conteneur ou à la validité des itérateurs. Question Q-d2b5552bb124d16e (ouverte)

Interaction

Au sein de ara::core::Vector, il existe plusieurs surcharges de insert qui permettent des opérations d'insertion alternatives :

• Insertion d'un élément via une référence rvalue T &&x [SWS_CORE_01368],
• Insertion d'un nombre déterminé d'éléments identiques avec size_type n, const T &x [SWS_CORE_01369],
• Insertion d'une séquence sur une plage d'itérateurs [first, last) [SWS_CORE_01370],
• Insertion via une liste d'initialisation std::initializer_list<T> [SWS_CORE_01371].

Des méthodes insert analogues sont également définies dans le module core par des conteneurs associatifs tels que ara::core::Map [SWS_CORE_01460] ainsi que par des classes de chaînes de caractères telles que ara::core::BasicString [SWS_CORE_03093].

Utilisation

La méthode insert selon [SWS_CORE_01368] est définie dans l'en-tête #include "ara/core/vector.h" en tant que fonction membre de la classe ara::core::Vector. Elle sert à l'insertion synchrone d'un élément via une référence rvalue (T&& x) à la position précédant l'itérateur position. Conformément au renvoi à [vector], la fonction devrait transférer le contenu de x dans le vecteur par sémantique de déplacement et renvoyer un iterator sur l'élément nouvellement inséré. Question Q-97f2551da8fd303f (ouverte)

Traitement des erreurs et restrictions

La spécification classe la fonction dans [SWS_CORE_01368] comme not exception safe. Aucun code d'erreur spécifique, valeur de retour pour l'indication d'erreur ou message adressé à DET ou DEM n'est défini. Interprétation : si une allocation de mémoire interne ou le déplacement des éléments échoue, aucune sécurité face aux exceptions ne devrait être garantie, ce qui peut laisser le conteneur dans un état incohérent ou conduire à un arrêt. Question Q-297ef8ff6f6eb76b (ouverte) De plus, il n'existe probablement aucune protection interne contre la concurrence, raison pour laquelle les accès simultanés doivent être synchronisés de manière externe.

Interaction

La variante rvalue [SWS_CORE_01368] forme une interface cohérente avec d'autres surcharges insert de ara::core::Vector :

• [SWS_CORE_01367] : insertion par copie d'une valeur au moyen d'une référence lvalue (const T& x).
• [SWS_CORE_01369] : insertion de n copies d'une valeur (size_type n, const T& x).
• [SWS_CORE_01370] : insertion d'une séquence sur une plage d'itérateurs (InputIterator first, InputIterator last).
• [SWS_CORE_01371] : insertion d'une liste au moyen de std::initializer_list<T>.

La fonction membre insert issue de [SWS_CORE_01369] appartient à la classe ara::core::Vector et est fournie via le fichier d'en-tête #include "ara/core/vector.h". Cette opération synchrone sert à insérer plusieurs éléments identiques. Interprétation : conformément à la référence spécifiée « As per corresponding usage in [vector] », l'appel devrait insérer exactement n copies de la valeur transmise x immédiatement avant la position d'itérateur position dans le vecteur et renvoyer un iterator pointant vers le premier élément nouvellement inséré. Question Q-c92add148c490868 (ouverte)

Concernant le traitement des erreurs et la robustesse, la fonction est expressément classée comme « not exception safe » dans [SWS_CORE_01369]. Aucun code d'erreur AUTOSAR spécifique ni notification destinée au DET ou au DEM n'est prévu pour cet appel de méthode.

La spécification ne contient aucune garantie particulière relative aux conditions de concurrence et d'appel. La modification du conteneur nécessite vraisemblablement une synchronisation externe, comme pour les vecteurs standard, étant donné que les accès concurrents en écriture ou en lecture ne devraient pas être sûrs au niveau des threads. Question (ouverte)

Au sein de ara::core::Vector, il existe en plus de cette surcharge pour des valeurs répétées d'autres variantes de insert :

• Insertion d'une valeur unique par copie ([SWS_CORE_01367]) ou par sémantique de déplacement ([SWS_CORE_01368]).
• Insertion d'une plage de valeurs via des itérateurs d'entrée ([SWS_CORE_01370]) ou via une std::initializer_list ([SWS_CORE_01371]).

La fonction membre modèle insert du conteneur séquentiel ara::core::Vector ([SWS_CORE_01370]) issue de l'en-tête #include "ara/core/vector.h" insère une séquence d'éléments de manière synchrone dans le vecteur. La plage à insérer est définie au moyen des itérateurs d'entrée first et last et est placée immédiatement avant l'emplacement désigné par position (type const_iterator). Comme valeur de retour, la fonction fournit un iterator qui pointe vers le premier élément inséré. La sémantique métier est décrite dans la spécification par « As per corresponding usage in [vector] » ([SWS_CORE_01370]) ; interprétation : cela devrait correspondre au comportement standardisé d'insertion de plage de std::vector. Question Q-c6cd06fb1964ead6 (ouverte)

Concernant le traitement des erreurs et la robustesse, la fonction est explicitement spécifiée comme not exception safe ([SWS_CORE_01370]). Aucun code d'erreur particulier, exception ou notification destinée aux moniteurs d'erreurs et de diagnostic (tels que le DET ou le DEM) n'est prévu dans le périmètre de la spécification.

Dans le cadre de l'interface de ara::core::Vector, cette surcharge par plage complète les autres méthodes d'insertion :

• l'insertion d'une valeur unique par copie ([SWS_CORE_01367]) ou par sémantique de déplacement ([SWS_CORE_01368]),
• l'insertion d'un nombre déterminé de valeurs identiques ([SWS_CORE_01369]),
• ainsi que l'insertion à partir d'une liste d'initialisation via std::initializer_list ([SWS_CORE_01371]).

Toutes les surcharges mentionnées au sein du vecteur partagent la restriction de ne pas être sûres vis-à-vis des exceptions ([SWS_CORE_01367], [SWS_CORE_01371]).

La fonction membre synchrone insert de la classe ara::core::Vector insère les éléments d'une liste d'initialisation à une position prédéfinie dans le conteneur [SWS_CORE_01371]. Elle est déclarée dans le fichier d'en-tête ara/core/vector.h [SWS_CORE_01371]. En guise de paramètres, la fonction attend un itérateur position de type const_iterator, qui marque l'emplacement d'insertion, ainsi que il de type std::initializer_list<T> [SWS_CORE_01371]. La valeur de retour est un iterator vers le premier élément inséré ou vers position si la liste est vide [SWS_CORE_01371].

Concernant la gestion des erreurs et la robustesse, la spécification classe explicitement cette opération comme « not exception safe » [SWS_CORE_01371]. Aucun code d'erreur ni message d'erreur AUTOSAR spécifique (DET/DEM) n'est prévu. Interprétation : du fait de la référence « As per corresponding usage in [vector] », le comportement à l'exécution, y compris d'éventuelles réallocations et l'invalidation d'itérateurs existants qui en découle, devrait correspondre à la sémantique de std::vector::insert [SWS_CORE_01371]. Question Q-67ac8e3de4d4ce7a (ouverte) Aucun mécanisme de synchronisation particulier pour les accès concurrents n'est spécifié.

Dans le module core, la fonction se situe dans le contexte d'autres opérations d'insertion de ara::core::Vector :

• Insertion d'un élément unique par copie [SWS_CORE_01367] ou sémantique de déplacement (move) [SWS_CORE_01368],
• Insertion de n copies d'une valeur [SWS_CORE_01369],
• Insertion basée sur une plage via deux itérateurs d'entrée [SWS_CORE_01370].

Toutes les surcharges dans ara::core::Vector partagent la propriété de ne pas être sûres vis-à-vis des exceptions [SWS_CORE_01367], [SWS_CORE_01368], [SWS_CORE_01369], [SWS_CORE_01370].

Utilisation et sémantique

La fonction membre pop_back du conteneur ara::core::Vector sert à supprimer de manière synchrone le dernier élément [SWS_CORE_01365]. La fonction est déclarée dans le fichier d'en-tête ara/core/vector.h et possède la signature void pop_back () [SWS_CORE_01365]. AUTOSAR renvoie explicitement, pour le comportement fonctionnel, à l'utilisation correspondante dans [vector], de sorte qu'aucun paramètre n'est transmis et qu'aucune valeur de retour n'existe [SWS_CORE_01365].

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

Concernant le traitement des erreurs, la spécification mentionne la propriété not exception safe [SWS_CORE_01365]. Comme aucun code d'erreur spécifique, valeur de retour ou mécanisme de vérification n'est défini dans le payload, il n'existe aucun traitement des erreurs intégré en cas d'appels non autorisés [SWS_CORE_01365]. Interprétation : avant l'appel, l'appelant doit s'assurer que le vecteur n'est pas vide ; un appel sur une instance vide devrait conduire à un comportement indéfini, de manière analogue à [vector]. Question Q-add313a489db4726 (ouverte)

Interaction et exigences associées

Un modèle correspondant se trouve dans la classe ara::core::BasicString de ara/core/string.h, dont la fonction pop_back supprime le dernier caractère conformément à [basic.string] et est également spécifiée comme not exception safe [SWS_CORE_03105]. Les deux définitions unifient la modification de structures de données séquentielles dans le module core [SWS_CORE_01365], [SWS_CORE_03105].

Utilisation

La fonction membre push_back dans la portée de ara::core::Vector insère un élément transmis par copie à la fin du conteneur [SWS_CORE_01363]. Elle est définie via l'en-tête #include "ara/core/vector.h", accepte une référence vers une valeur constante const T &x et n'a pas de valeur de retour (void) [SWS_CORE_01363]. L'appel s'effectue de manière synchrone dans le contexte de l'appelant.

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

La spécification s'écarte de [vector] en ce que la fonction est déclarée comme étant conditionnellement noexcept : sa garantie de non-levée s'applique si et seulement si std::is_nothrow_copy_assignable<T>::value est vérifié [SWS_CORE_01363]. La sécurité des exceptions est ainsi définie comme « conditionally exception safe » [SWS_CORE_01363]. Aucun code d'erreur spécifique ni message d'erreur via DET ou DEM n'est défini pour cette fonction.

Interaction et exigences associées

Pour les objets déplaçables, ara::core::Vector fournit la surcharge void push_back(T &&x), dont la propriété noexcept est couplée de manière analogue à std::is_nothrow_move_assignable<T>::value [SWS_CORE_01364]. En revanche, push_back dans ara::core::BasicString ne possède aucune garantie noexcept et est classée comme « not exception safe » [SWS_CORE_03083].

Interprétation : le comportement interne d'allocation de mémoire et de réallocation lors de l'insertion devrait s'orienter, en dehors de la déclaration noexcept spécifique, vers les prescriptions de la norme C++ pour [vector]. Question Q-202fb07b334cde64 (ouverte)

La fonction membre push_back de ara::core::Vector sert à ajouter de manière synchrone un élément à la fin du vecteur en utilisant la sémantique de déplacement ([SWS_CORE_01364]). Elle est mise à disposition via l'en-tête #include "ara/core/vector.h", accepte une référence rvalue T &&x et n'a pas de valeur de retour (void) ([SWS_CORE_01364]).

En matière de traitement des erreurs et de comportement face aux exceptions, les propriétés suivantes s'appliquent :

• La méthode est classée comme conditionnellement sûre au regard des exceptions (conditionally exception safe) ([SWS_CORE_01364]).
• La garantie noexcept est liée au type : noexcept(std::is_nothrow_move_assignable<T>::value) ([SWS_CORE_01364]). Si l'opérateur d'assignation par déplacement de T n'est pas déclaré sans exception, des exceptions devraient survenir lors des allocations de mémoire ou des déplacements d'éléments. Question Q-3b8b58d0b218fe21 (ouverte)

Le fonctionnement suit la sémantique habituelle de [vector], mais s'en écarte par la déclaration noexcept conditionnelle ([SWS_CORE_01364]). Comme l'opération modifie le conteneur, des accès simultanés à la même instance sans synchronisation externe ne devraient pas être sûrs pour les threads. Question (ouverte)

Dans l'interaction entre les interfaces, cette variante par déplacement complète la surcharge par copie push_back(const T &x) ([SWS_CORE_01363]), laquelle est couplée de manière analogue à is_nothrow_copy_assignable. Il convient de la distinguer de la fonction membre de même nom dans ara::core::BasicString ([SWS_CORE_03083]), qui ajoute des caractères individuels et est définie comme non sûre au regard des exceptions.