classe ara::core::BasicString

L'opérateur d'affectation operator+= de la classe ara::core::BasicString ([SWS_CORE_03072] de #include "ara/core/string.h") ajoute de manière synchrone le contenu d'une instance BasicString transmise à l'objet actuel. La sémantique fonctionnelle suit ici l'utilisation correspondante dans [basic.string] ([SWS_CORE_03072]). L'appel renvoie une référence à l'instance modifiée (*this), ce qui permet les chaînages d'affectations.

En ce qui concerne la gestion des erreurs, l'opération est explicitement déclarée dans la spécification comme « not exception safe » ([SWS_CORE_03072]). Aucun code d'erreur spécifique ni mécanisme de notification via DET ou DEM n'est défini pour cet élément. Si une allocation de mémoire interne venait à échouer, la méthode n'offre par conséquent aucune garantie de sécurité vis-à-vis des exceptions.

Concernant la concurrence et les restrictions, il convient de noter que l'appel modifie directement l'état de l'instance. La charge utile ne mentionnant aucun mécanisme de synchronisation, un accès concurrent en lecture ou en écriture au même objet par plusieurs threads sans synchronisation externe ne devrait pas être sûr pour les threads. Question Q-352f9d72ad3dfdbd (ouverte)

L'opérateur forme avec d'autres surcharges de operator+= l'interface d'extension de chaîne de caractères, par exemple pour les caractères individuels ([SWS_CORE_03074]), les pointeurs de caractères bruts ([SWS_CORE_03073]), les listes d'initialisation ([SWS_CORE_03075]) ainsi que StringView ([SWS_CORE_03307]). L'ensemble de ces opérateurs de modification partagent la propriété « not exception safe » et complètent les constructeurs de base de ara::core::BasicString ([SWS_CORE_03024], [SWS_CORE_03025]).

Utilisation

L'opérateur d'assignation operator+= de la classe ara::core::BasicString ajoute de manière synchrone une chaîne de caractères basée sur un pointeur à la chaîne de caractères existante et renvoie une référence vers l'objet modifié [SWS_CORE_03073]. La fonction est incluse via le fichier d'en-tête #include "ara/core/string.h" et reçoit comme paramètre un pointeur s de type const value_type * [SWS_CORE_03073]. La sémantique fonctionnelle suit la définition standardisée issue de [basic.string], le type de caractère standard charT étant remplacé par value_type comme divergence essentielle [SWS_CORE_03073].

Traitement des erreurs et restrictions

Concernant la sécurité vis-à-vis des exceptions, la fonction membre est explicitement déclarée comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_03073]. Des codes d'erreur spécifiques, des valeurs de retour pour indiquer une erreur ou des messages d'erreur au DET ou au DEM ne sont pas spécifiés pour cet opérateur. Interprétation : en cas d'échec d'allocations de mémoire internes nécessaires pendant l'agrandissement de la chaîne de caractères, aucun état cohérent de l'objet ne devrait par conséquent être garanti et il n'existe pas de canal d'erreur dédié dans l'environnement AUTOSAR Adaptive. Question Q-a1498ddbc09bcfa9 (ouverte)

Interaction

La méthode complète les autres opérateurs d'assignation au sein de ara::core::BasicString, qui réalisent l'ajout d'instances complètes de chaînes de caractères [SWS_CORE_03072], de caractères individuels [SWS_CORE_03074], de listes d'initialisateurs [SWS_CORE_03075] ou d'objets StringView [SWS_CORE_03307]. Tout comme les constructeurs pour pointeurs de caractères bruts [SWS_CORE_03028] [SWS_CORE_03029], toutes ces variantes sont spécifiées comme non sûres vis-à-vis des exceptions.

La fonction membre operator+= de la classe ara::core::BasicString permet l'ajout synchrone d'un caractère individuel c de type value_type à l'objet de chaîne de caractères appelant [SWS_CORE_03074]. La déclaration est contenue dans l'en-tête ara/core/string.h [SWS_CORE_03074]. Le comportement correspond à la spécification dans [basic.string], le type de paramètre charT ayant été remplacé de façon dérogatoire par value_type [SWS_CORE_03074]. Une référence vers l'objet modifié (BasicString &) est fournie comme valeur de retour, ce qui prend en charge les appels chaînés.

En matière de robustesse et de traitement des erreurs, l'opération est classée comme not exception safe [SWS_CORE_03074]. Des codes d'erreur spécifiques ainsi que des messages au DET ou au DEM ne sont pas définis pour cette fonction. Interprétation : la classification comme non sûre vis-à-vis des exceptions devrait reposer sur le fait qu'en cas de dépassement de la capacité actuelle du tampon, une allocation dynamique doit être déclenchée via l'allocateur sous-jacent, laquelle peut échouer en cas de manque de mémoire. Question Q-d74ec80829327ce0 (ouverte)

Concernant la concurrence et les conditions aux limites, la fonction modifie directement l'instance ; des accès simultanés en lecture ou en écriture sans synchronisation externe ne sont donc pas sûrs. En combinaison avec d'autres interfaces, l'opérateur complète l'instanciation via des constructeurs tels que [SWS_CORE_03024] ou [SWS_CORE_03025] ainsi que des affectations composées alternatives pour des chaînes de caractères complètes [SWS_CORE_03072], des pointeurs de chaînes de caractères [SWS_CORE_03073], des listes d'initialisation [SWS_CORE_03075] et des vues de chaînes de caractères [SWS_CORE_03307].

La fonction membre operator+= de ara::core::BasicString ([SWS_CORE_03075]) ajoute de manière synchrone les caractères d'une std::initializer_list<value_type> à l'objet chaîne existant. Comme valeur de retour, la méthode fournit une référence vers la chaîne de caractères modifiée (*this). Le comportement est conforme au standard C++ pour [basic.string], charT étant remplacé par value_type ([SWS_CORE_03075]). Pour l'utilisation, l'en-tête ara/core/string.h doit être inclus ([SWS_CORE_03075]).

Concernant le traitement des erreurs et la robustesse, la fonction est classée comme not exception safe ([SWS_CORE_03075]). Interprétation : il est à présumer qu'en cas de mémoire insuffisante lors d'une réallocation nécessaire, des exceptions peuvent être levées sans qu'une garantie forte d'exception ne soit assurée pour le contenu antérieur du tampon. Question Q-0f3d6328fb6bfd73 (ouverte)

Concernant la concurrence et les restrictions, l'appel s'effectue de manière synchrone dans le contexte du thread appelant. L'instance appelée étant directement modifiée, l'accès simultané de plusieurs threads sans synchronisation externe n'est pas sûr pour les threads.

En interaction avec d'autres interfaces, cette surcharge complète les autres opérateurs d'ajout de ara::core::BasicString, dont l'ajout de chaînes de caractères ([SWS_CORE_03072]), de tableaux de caractères ([SWS_CORE_03073]), de caractères individuels ([SWS_CORE_03074]) ou d'une StringView ([SWS_CORE_03307]). De plus, la liste d'initialisation correspond sémantiquement au constructeur correspondant ([SWS_CORE_03032]).

La fonction membre operator+= de la classe ara::core::BasicString ajoute de manière synchrone une séquence de caractères transmise par StringView sv à l'objet chaîne appelant et renvoie une référence à cet objet modifié [SWS_CORE_03307]. L'opération est définie via le fichier d'en-tête #include "ara/core/string.h", le comportement fonctionnel suivant les conventions générales de [basic.string] [SWS_CORE_03307].

Gestion des erreurs et concurrence

Concernant l'exécution, la fonction est expressément classée comme not exception safe [SWS_CORE_03307]. Aucun code d'erreur spécifique pour DET ou DEM n'est prescrit. Si une allocation interne de mémoire devait échouer lors du prolongement de la chaîne de caractères, il ne devrait pas être garanti que l'état interne de l'instance reste inchangé. En l'absence de mécanismes de synchronisation intégrés, une absence de thread-safety est à supposer en cas d'accès concurrent en écriture ou en lecture de plusieurs threads à la même instance (Interprétation). Question Q-1bed85bd42475f62 (ouverte)

Interaction

L'opérateur s'intègre parfaitement dans la structure de la classe ara::core::BasicString et complète les surcharges alternatives de operator+= pour les chaînes entières [SWS_CORE_03072], les pointeurs de caractères const value_type* [SWS_CORE_03073], les caractères individuels [SWS_CORE_03074] et les listes d'initialisation [SWS_CORE_03075]. La création des instances de chaînes impliquées s'effectue via les constructeurs associés de la classe, par exemple le constructeur par défaut [SWS_CORE_03024] ou les constructeurs de copie et de déplacement [SWS_CORE_03033], [SWS_CORE_03034].

Utilisation

La fonction BasicString() du fichier d'en-tête #include "ara/core/string.h" est le constructeur par défaut sans paramètre de la classe ara::core::BasicString ([SWS_CORE_03024]). L'appel s'effectue de manière synchrone et ne renvoie aucune valeur de retour en tant que constructeur. Le comportement suit la définition correspondante dans [basic.string] ([SWS_CORE_03024]) ; l'instance créée devrait par conséquent représenter une chaîne de caractères vide. Question Q-f36b11fa590a6111 (ouverte)

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

L'élément est spécifié comme conditionnellement sûr vis-à-vis des exceptions (conditionally exception safe) ([SWS_CORE_03024]). Selon la spécification, il n'existe pas de codes d'erreur spécifiques ni de messages DET ou DEM. Via la signature BasicString () noexcept(noexcept(Allocator()));, la sécurité vis-à-vis des exceptions est directement couplée au constructeur par défaut de l'allocateur ([SWS_CORE_03024]). Si la création de Allocator() ne lève aucune exception, la construction de BasicString est également garantie sans exception.

Interaction et restrictions

Dans le contexte des autres interfaces de ara::core::BasicString, les dépendances suivantes sont pertinentes :

• Si un allocateur déjà instancié est transmis, la signature garantit une sécurité inconditionnelle vis-à-vis des exceptions (exception safe / noexcept) ([SWS_CORE_03025]).
• En revanche, d'autres initialisations – par exemple via des sous-parties ([SWS_CORE_03026], [SWS_CORE_03027]), des pointeurs ([SWS_CORE_03028], [SWS_CORE_03029]), des séquences de caractères ([SWS_CORE_03030]), des itérateurs ([SWS_CORE_03031]), des listes d'initialisation ([SWS_CORE_03032]) ou des opérations de copie et de déplacement avec allocateur ([SWS_CORE_03033], [SWS_CORE_03034]) – sont classées comme not exception safe.
• L'instance initialisée peut être étendue de manière synchrone, notamment par des surcharges de operator+= pour des chaînes de caractères ([SWS_CORE_03072]), des pointeurs de caractères ([SWS_CORE_03073]), des caractères individuels ([SWS_CORE_03074]), des initializer lists ([SWS_CORE_03075]) ainsi que StringView ([SWS_CORE_03307]).
• De plus, l'objet peut être utilisé pour la construction d'un Bitset ([SWS_CORE_01749]).

Le constructeur explicite BasicString(const Allocator &a) issu du fichier d'en-tête #include "ara/core/string.h" initialise une instance vide de ara::core::BasicString en utilisant l'allocateur transmis [SWS_CORE_03025]. Le comportement sémantique est conforme à la section de la norme C++ [basic.string] [SWS_CORE_03025]. Le mot-clé explicit empêche les conversions de type implicites involontaires à partir d'une instance d'allocateur [SWS_CORE_03025].

Concernant la gestion des erreurs et le traitement des exceptions, la fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_03025]. À la différence du constructeur par défaut [SWS_CORE_03024], dont la sécurité vis-à-vis des exceptions dépend conditionnellement de noexcept(noexcept(Allocator())), cet appel garantit toujours une création sans erreur et sans exceptions [SWS_CORE_03025], [SWS_CORE_03024]. Interprétation : la sécurité inconditionnelle vis-à-vis des exceptions devrait reposer sur le fait qu'aucune étape d'allocation consommatrice de mémoire n'a besoin d'être exécutée lors de l'initialisation d'une chaîne de caractères vide. Question Q-88df57e7a9c2abda (ouverte)

En interaction avec d'autres constructeurs de la classe tels que [SWS_CORE_03026] ou [SWS_CORE_03028], qui copient des données et sont classés comme non sûrs vis-à-vis des exceptions (not exception safe), ce constructeur sert de point d'entrée sûr. La chaîne de caractères créée peut ensuite être étendue dynamiquement via des modificateurs tels que operator+= ([SWS_CORE_03072], [SWS_CORE_03307]) ou être utilisée comme entrée pour des types tels que Bitset [SWS_CORE_01749].

Utilisation

La fonction Basic représente un constructeur de la classe ara::core::BasicString, fourni via le fichier d'en-tête #include "ara/core/string.h" [SWS_CORE_03026]. Il crée de manière synchrone une nouvelle chaîne de caractères sous forme de sous-chaîne à partir de l'objet source str à partir de la position d'index pos selon la sémantique de [basic.string] [SWS_CORE_03026]. Les paramètres suivants sont alors traités :

• str : référence vers l'instance source à copier du type BasicString [SWS_CORE_03026].
• pos : position de départ basée sur zéro de la sous-chaîne, de type size_type [SWS_CORE_03026].
• a : allocateur pour la gestion de la mémoire, défini par défaut avec Allocator() [SWS_CORE_03026].

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

Pour la fonction, la propriété not exception safe est définie dans la spécification [SWS_CORE_03026]. Aucun code d'erreur spécifique ni message DET ou DEM n'est défini. Interprétation : étant donné que le constructeur suit le comportement standard de [basic.string] et ne garantit pas la sécurité vis-à-vis des exceptions, des valeurs d'index invalides pour pos ainsi que des échecs d'allocations de mémoire devraient entraîner le déclenchement d'exceptions [SWS_CORE_03026]. Question Q-7ea120ac992dc5ac (ouverte)

Interaction et exigences associées

Au sein de ara::core::BasicString, ce constructeur complète la variante avec limitation de longueur supplémentaire n [SWS_CORE_03027] ainsi que les surcharges pour pointeurs, itérateurs et listes d'initialisation [SWS_CORE_03028], [SWS_CORE_03031], [SWS_CORE_03032]. À la différence des constructeurs sans chaîne source, qui sont conditionnellement sûrs vis-à-vis des exceptions [SWS_CORE_03024] ou déclarés comme noexcept [SWS_CORE_03025], la reprise dynamique de sous-chaînes requiert une attention particulière aux erreurs d'allocation potentielles. De plus, BasicString sert de base de paramètres dans d'autres composants de modules tels que Bitset [SWS_CORE_01749].

Le constructeur [SWS_CORE_03027] de la classe ara::core::BasicString sert à la création synchrone d'une nouvelle chaîne de caractères en tant que sous-séquence issue d'une chaîne source str. À partir de l'index pos, jusqu'à n caractères sont repris. Via le paramètre optionnel a, un allocateur défini par l'utilisateur peut être transmis ; sinon, une instance d'allocateur par défaut est créée par défaut. La définition est fournie via l'en-tête #include "ara/core/string.h".

Concernant la robustesse, la fonction est déclarée comme not exception safe ([SWS_CORE_03027]). Selon la spécification conforme à [basic.string], ce constructeur devrait échouer si pos dépasse la longueur de la chaîne source ou si l'allocation du nouveau tampon échoue. Question Q-31041ea019720daf (ouverte) Cela contraste avec les constructeurs par défaut et avec allocateur tels que [SWS_CORE_03024] et [SWS_CORE_03025], qui sont spécifiés comme conditionnellement sûrs vis-à-vis des exceptions ou explicitement avec noexcept.

En interaction au sein de ara::core::BasicString, la fonction complète des surcharges alternatives : tandis que [SWS_CORE_03026] copie la sous-chaîne à partir de pos jusqu'à la fin de la chaîne, [SWS_CORE_03027] autorise la limitation explicite de la longueur. D'autres alternatives de création offrent des initialisations basées sur des itérateurs ([SWS_CORE_03031]) ou basées sur des pointeurs ([SWS_CORE_03028]). De plus, le même modèle de sous-chaîne avec pos et n est également utilisé dans des classes apparentées telles que Bitset dans [SWS_CORE_01749].

La fonction constructeur de la classe ara::core::BasicString issue de l'en-tête ara/core/string.h crée de manière synchrone une chaîne de caractères à partir d'un pointeur s vers un tableau de caractères et d'une indication explicite de longueur n [SWS_CORE_03028]. Via le paramètre a, un allocateur défini par l'utilisateur peut être transmis optionnellement, retombant par défaut sur Allocator() [SWS_CORE_03028]. La sémantique correspond à la définition dans [basic.string], avec pour divergence le remplacement du type de paramètre charT par value_type [SWS_CORE_03028].

Dans la spécification, la fonction est désignée comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_03028]. Cela la distingue des initialisations sûres vis-à-vis des exceptions telles que le constructeur avec allocateur [SWS_CORE_03025] ou le constructeur par défaut conditionnellement sûr vis-à-vis des exceptions [SWS_CORE_03024]. Aucun code d'erreur, valeur de retour ou message de diagnostic vers DEM ou DET spécifique n'est prévu. En tant que précondition essentielle, l'appelant devrait probablement devoir s'assurer que s pointe vers une zone mémoire valide comportant au moins n éléments contigus (interprétation), afin d'exclure tout comportement indéfini. Question Q-957a57c885a2e702 (ouverte)

Au sein de la classe ara::core::BasicString, cette surcharge complète la construction sans indication de longueur pour les chaînes de caractères terminées par un caractère nul [SWS_CORE_03029] ainsi que les constructeurs pour les séquences de caractères identiques [SWS_CORE_03030] ou de sous-chaînes [SWS_CORE_03027]. Après la création, l'objet peut être modifié par des opérateurs d'affectation et de concaténation [SWS_CORE_03072]. De plus, la chaîne de caractères résultante sert d'entrée pour les interfaces de types de données apparentés, par exemple pour l'initialisation d'un Bitset [SWS_CORE_01749].

Le constructeur [SWS_CORE_03029] initialise une instance de ara::core::BasicString à partir d'un pointeur terminé par zéro vers des chaînes de caractères de type const value_type* et d'un allocateur optionnel. Sa sémantique suit la définition standard de [basic.string], charT étant remplacé par value_type [SWS_CORE_03029]. Le fichier d'en-tête est #include "ara/core/string.h" [SWS_CORE_03029].

Concernant le comportement d'erreur et la sécurité vis-à-vis des exceptions, la fonction est explicitement spécifiée comme not exception safe [SWS_CORE_03029]. Si une allocation de mémoire ou une erreur survient pendant la construction, aucune garantie d'exception n'est assurée. En revanche, les constructeurs par défaut tels que [SWS_CORE_03025] sont classés comme noexcept et exception safe ou [SWS_CORE_03024] comme conditionnellement sûrs vis-à-vis des exceptions (conditionally exception safe).

La spécification définit les interactions au sein de la famille de constructeurs BasicString :

• Si le nombre de caractères est explicitement spécifié, la surcharge avec paramètre de longueur (const value_type *s, size_type n, ...) selon [SWS_CORE_03028] doit être employée.
• D'autres alternatives comprennent des constructeurs de sous-plages à partir de chaînes existantes [SWS_CORE_03026], [SWS_CORE_03027], des constructeurs de remplissage [SWS_CORE_03030] ainsi que des listes d'itérateurs [SWS_CORE_03031] et d'initialisateurs [SWS_CORE_03032].
• Pour la concaténation ultérieure avec des pointeurs de chaînes de caractères bruts correspond operator+= selon [SWS_CORE_03073].
• De plus, BasicString sert de base de paramètres dans d'autres classes utilitaires telles que Bitset selon [SWS_CORE_01749].

Les appelants doivent s'assurer que le pointeur s est valide et correctement terminé par zéro (interprétation : étant donné qu'en l'absence d'indication de longueur, la terminaison sert à la détermination de la longueur conformément au comportement standard). Question Q-7e0172674e115dea (ouverte) Le constructeur étant exécuté de manière synchrone, il convient de prendre en compte dans les contextes critiques pour la sécurité que de la mémoire potentiellement dynamique est obtenue via l'allocateur.

Utilisation

Le constructeur [SWS_CORE_03030] de la classe ara::core::BasicString (défini dans l'en-tête ara/core/string.h) génère de manière synchrone une chaîne de caractères à partir de n copies du caractère c de type value_type. Le comportement fonctionnel suit la spécification de la norme C++ [basic.string] avec la dérogation que charT est remplacé par value_type. Facultativement, un allocateur personnalisé a peut être transmis, pour lequel Allocator() est instancié par défaut.

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

La spécification classe ce constructeur comme not exception safe, ce qui le distingue des constructeurs noexcept garantis tels que [SWS_CORE_03025] ou du constructeur par défaut conditionnellement sûr [SWS_CORE_03024]. Interprétation : l'absence de sécurité vis-à-vis des exceptions devrait principalement être due à des échecs lors de l'allocation dynamique de mémoire pour n caractères. Question Q-87ae8b5cae690fdb (ouverte) Aucun code d'erreur AUTOSAR spécifique ni message vers DET ou DEM n'est spécifié pour cet appel.

Concurrence et interaction

Les accès simultanés de plusieurs threads à la même instance sans synchronisation externe ne sont pas thread-safe. Après la création, la chaîne de caractères peut être modifiée via des opérateurs de concaténation tels que operator+= pour les caractères uniques ([SWS_CORE_03074]) ou les chaînes ([SWS_CORE_03072]). La chaîne créée peut également servir à initialiser ara::core::Bitset conformément à [SWS_CORE_01749]. Pour d'autres modes de création, des constructeurs via des pointeurs ([SWS_CORE_03028], [SWS_CORE_03029]) ou des listes d'initialisation ([SWS_CORE_03032]) sont disponibles.

Utilisation

La fonction template représente le constructeur de plage de la classe ara::core::BasicString dans l'en-tête <ara/core/string.h> [SWS_CORE_03031]. Elle sert à l'initialisation synchrone d'une chaîne de caractères à partir d'une séquence définie par les itérateurs d'entrée begin et end de type InputIterator [SWS_CORE_03031]. Une instance d'allocateur personnalisée peut être transmise de manière optionnelle via le paramètre a ; si ce paramètre n'est pas renseigné, l'instance par défaut Allocator() est créée [SWS_CORE_03031]. La sémantique fonctionnelle suit alors les exigences du standard C++ pour [basic.string] [SWS_CORE_03031].

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

La spécification déclare explicitement la fonction comme not exception safe [SWS_CORE_03031]. Aucun message DET ou DEM spécifique à AUTOSAR n'est émis, car le comportement correspond à celui de la bibliothèque standard C++ [SWS_CORE_03031]. Interprétation : l'absence de sécurité vis-à-vis des exceptions devrait être imputable à d'éventuelles erreurs d'allocation de mémoire par l'allocateur ou à l'échec d'opérations des itérateurs transmis. Question Q-676411ee17d37217 (ouverte)

Concurrence et restrictions

L'appel est synchrone dans le contexte du thread appelant. Contrairement au constructeur par défaut [SWS_CORE_03024] ou au constructeur d'allocateur pur [SWS_CORE_03025], ce constructeur n'est pas déclaré comme noexcept. Les appelants doivent par conséquent s'assurer que la plage [begin, end) est valide et que les éléments référencés peuvent être lus sans erreur.

Interaction

La fonction complète les constructeurs alternatifs de ara::core::BasicString, dont les surcharges de sous-chaînes [SWS_CORE_03026], de tableaux de caractères [SWS_CORE_03028] et de listes d'initialisateurs [SWS_CORE_03032], qui présentent la même classification d'exception. Après la construction, l'instance peut être modifiée via des opérateurs de concaténation tels que operator+= [SWS_CORE_03072] ou servir à l'initialisation de types dépendants tels que Bitset [SWS_CORE_01749].

Le constructeur BasicString sert à l'initialisation synchrone d'une instance de ara::core::BasicString à l'aide d'une liste d'initialisation ([SWS_CORE_03032]). La déclaration s'effectue via le fichier d'en-tête #include "ara/core/string.h" dans la portée de la classe ara::core::BasicString ([SWS_CORE_03032]). Le comportement suit la définition de [basic.string], où, conformément à la norme, charT est remplacé par value_type ([SWS_CORE_03032]). Une std::initializer_list<value_type> ainsi que, facultativement, un allocateur sont transmis en paramètres ([SWS_CORE_03032]).

En ce qui concerne le traitement des erreurs et la gestion des exceptions, le constructeur est spécifié comme not exception safe ([SWS_CORE_03032]). Cela le distingue du constructeur par défaut ([SWS_CORE_03024]) ou du constructeur explicite avec allocateur ([SWS_CORE_03025]), qui sont déclarés comme sûrs vis-à-vis des exceptions ou noexcept. Aucun code d'erreur spécifique à AUTOSAR, ni aucun message DET ou DEM n'est défini pour ce constructeur. Interprétation : en cas de mémoire insuffisante, la création de l'objet devrait échouer car de la mémoire dynamique doit être allouée pour les éléments de la liste d'initialisation. Question Q-7ecc7431c1c2f54c (ouverte)

Dans l'interaction avec le module core, la fonction complète des modes de construction alternatifs, tels que la création à partir de sous-chaînes ([SWS_CORE_03026], [SWS_CORE_03027]), de pointeurs ([SWS_CORE_03028], [SWS_CORE_03029]) ou d'itérateurs ([SWS_CORE_03031]). Pour l'extension ultérieure d'une chaîne existante par une liste d'initialisation, le operator+= correspondant est disponible ([SWS_CORE_03075]). De plus, les instances de BasicString créées peuvent être utilisées pour l'initialisation de types de données apparentés tels que Bitset ([SWS_CORE_01749]).

Le constructeur de copie [SWS_CORE_03033] de la classe ara::core::BasicString sert à la création synchrone d'une nouvelle chaîne de caractères en tant que copie d'une instance existante avec transmission explicite d'un allocateur. La déclaration de la fonction BasicString (const BasicString &, const Allocator &); est fournie via l'en-tête #include "ara/core/string.h" [SWS_CORE_03033]. La sémantique fonctionnelle s'aligne ici sur l'utilisation correspondante dans le modèle standard [basic.string] [SWS_CORE_03033].

Concernant le traitement des erreurs, la fonction de constructeur est expressément classée dans la spécification comme not exception safe [SWS_CORE_03033]. Il n'existe aucun code d'erreur AUTOSAR spécifique ni notification vers des modules de diagnostic tels que DET ou DEM pour cet appel ; les exceptions lors de l'allocation dynamique de mémoire par l'allocateur devraient donc être soumises au comportement général de [basic.string]. Question Q-496b847c39fc25ae (ouverte)

En ce qui concerne la concurrence et les conditions aux limites, la transmission de l'instance source par const BasicString & exige que l'objet source ne soit pas modifié simultanément pendant l'opération de copie. Des accès simultanés en lecture depuis plusieurs threads sont autorisés, tandis que des accès concurrents en écriture non protégés conduisent probablement à des incohérences de données. Question Q-daa5ef2c4672b657 (ouverte)

En interaction avec des éléments de spécification apparentés, le constructeur coexiste avec des voies d'initialisation alternatives telles que le constructeur de déplacement avec allocateur [SWS_CORE_03034], le constructeur par défaut [SWS_CORE_03024] ou le constructeur avec allocateur [SWS_CORE_03025]. L'objet créé peut être modifié de manière transparente via des opérateurs tels que operator+= [SWS_CORE_03072] ou être utilisé pour l'initialisation de types dépendants tels que Bitset [SWS_CORE_01749].

Le constructeur de déplacement [SWS_CORE_03034] de la classe ara::core::BasicString est fourni via le fichier d'en-tête #include "ara/core/string.h". Il génère de manière synchrone une nouvelle chaîne de caractères en prenant en charge les données d'une instance existante et en les liant à un allocateur explicitement spécifié. Le comportement sémantique et les exigences correspondent alors aux dispositions de la norme ISO C++ dans [basic.string].

Dans le contexte d'appel, la fonction requiert deux paramètres : une référence rvalue vers un objet source (BasicString&&) ainsi qu'une instance d'allocateur (const Allocator&). L'objet source reste, après l'opération de déplacement, dans un état valide mais modifié. Concernant le traitement des erreurs, la fonction est classée dans [SWS_CORE_03034] comme not exception safe. Interprétation : cela devrait être dû au fait qu'avec un allocateur différent ou incompatible, de la nouvelle mémoire doit être allouée et les éléments doivent être copiés, ce qui peut échouer en cas de pénurie de mémoire. Question Q-2a89ad749ae1b2f6 (ouverte) Cela distingue le constructeur des surcharges strictement sûres vis-à-vis des exceptions telles que [SWS_CORE_03025] ou des variantes conditionnellement sûres vis-à-vis des exceptions telles que [SWS_CORE_03024].

En interaction au sein de core, la signature complète la palette de méthodes de création aux côtés du constructeur de copie avec allocateur [SWS_CORE_03033] et des initialiseurs de sous-chaîne tels que [SWS_CORE_03026]. Après une instanciation réussie, la chaîne de caractères peut être modifiée, par exemple en ajoutant du contenu via operator+= ([SWS_CORE_03072], [SWS_CORE_03307]), ou servir d'entrée pour des types de données dépendants tels que Bitset conformément à [SWS_CORE_01749].

Utilisation et sémantique

La fonction membre append de la classe ara::core::BasicString ([SWS_CORE_03076]) issue du fichier d'en-tête #include "ara/core/string.h" sert à ajouter de manière synchrone un objet chaîne de caractères complet str de type BasicString à l'instance appelante. La sémantique suit la définition standardisée du C++ sous [basic.string] ; en tant que valeur de retour, la fonction renvoie une référence vers l'objet modifié (*this) ([SWS_CORE_03076]).

Gestion des erreurs et conditions limites

Concernant la sécurité vis-à-vis des exceptions, l'opération est explicitement classée comme not exception safe ([SWS_CORE_03076]). Interprétation : si une erreur survient pendant l'exécution (par exemple en cas de mémoire insuffisante), l'état de la chaîne de caractères devrait être indéterminé, car aucune garantie de rétablissement n'est spécifiée. Contrairement aux variantes avec indices de position comme [SWS_CORE_03077] ou [SWS_CORE_03309] (déclenchement de IsoStdOutOfRangeViolation) ou aux contrôles de taille de tampon comme [SWS_CORE_03078] (déclenchement de IsoStdLengthErrorViolation), [SWS_CORE_03076] ne définit aucune violation particulière. Question Q-57504af4ee633d0b (ouverte)

Interaction et surcharges

La fonction fait partie d'une famille de surcharges au sein de ara::core::BasicString :

• Ajout de sous-chaînes via des indications de position et de longueur ([SWS_CORE_03077]).
• Prise en charge de tableaux de caractères du type value_type* avec une longueur définie ([SWS_CORE_03078]) ou sous la forme d'une chaîne terminée par un caractère nul ([SWS_CORE_03079]).
• Ajouts multiples de caractères individuels ([SWS_CORE_03080]) ou affectation via std::initializer_list<value_type> ([SWS_CORE_03082]).
• Intégration de plages d'itérateurs ([SWS_CORE_03081]) ainsi que de vues de chaînes au moyen de StringView ([SWS_CORE_03308]) et de modèles spécifiques au type ([SWS_CORE_03309]).

La fonction membre append de la classe ara::core::BasicString ([SWS_CORE_03077], déclarée dans #include "ara/core/string.h") ajoute de manière synchrone une sous-chaîne d'une autre instance de BasicString str à l'objet actuel. Les paramètres pos et n (par défaut npos) déterminent l'index de départ et le nombre maximal de caractères au sein de str. Comme valeur de retour, une référence sur l'objet cible modifié (*this) est fournie.

Concernant la sémantique et le comportement de l'interface, la fonction suit la définition dans [basic.string] du standard C++, mais s'en écarte pour le traitement des erreurs : si pos > str.size() est vrai, une IsoStdOutOfRangeViolation est déclenchée conformément à [SWS_CORE_03077] (de manière analogue à std::out_of_range). La spécification classe expressément l'opération comme not exception safe, raison pour laquelle, en cas d'erreur, aucune garantie n'est fournie quant à un état d'objet inchangé ou cohérent.

En l'absence de mécanismes de synchronisation documentés, un appel concurrent sur la même instance ne devrait pas être thread-safe. Question Q-ec3b029fca94ad8a (ouverte) Pour les sources de données alternatives, d'autres surcharges sont disponibles dans le module : chaînes entières ([SWS_CORE_03076]), tampons et pointeurs ([SWS_CORE_03078], [SWS_CORE_03079]), répétitions de caractères ([SWS_CORE_03080]), paires d'itérateurs ([SWS_CORE_03081]), listes d'initialisateurs ([SWS_CORE_03082]) ainsi qu'objets StringView ([SWS_CORE_03308], [SWS_CORE_03309]).

La fonction membre append de la classe ara::core::BasicString ([SWS_CORE_03078]) ajoute de manière synchrone les n premiers caractères du tableau de caractères s transmis, de type const value_type*, à la chaîne existante. Comme valeur de retour, la fonction fournit une référence vers l'instance modifiée (BasicString&), ce qui permet le chaînage d'appels successifs. La déclaration est disponible via le fichier d'en-tête #include "ara/core/string.h".

Le comportement fonctionnel suit la spécification de std::basic_string::append conformément à [basic.string], mais présente des divergences spécifiques à AUTOSAR ([SWS_CORE_03078]) :

• Le paramètre de modèle charT est remplacé par le type value_type.
• Si la longueur résultante dépasse la limite de capacité (condition size() > n + max_size()), la violation IsoStdLengthErrorViolation est déclenchée au lieu d'une std::length_error.

Concernant la sécurité d'exécution, l'opération est explicitement spécifiée comme not exception safe ([SWS_CORE_03078]). Si une erreur ou une violation survient pendant l'allocation de mémoire ou lors de la copie, l'objet ne garantit aucun état intermédiaire cohérent.

La méthode complète les autres surcharges de append au sein de ara::core::BasicString. Celles-ci comprennent l'ajout d'instances complètes ([SWS_CORE_03076]), de sous-chaînes avec contrôle de plage via IsoStdOutOfRangeViolation ([SWS_CORE_03077]), de chaînes terminées par un caractère nul ([SWS_CORE_03079]), de séquences de caractères identiques ([SWS_CORE_03080]), de plages d'itérateurs ([SWS_CORE_03081]), de listes d'initialisation ([SWS_CORE_03082]) ainsi que d'objets StringView ([SWS_CORE_03308], [SWS_CORE_03309]).

La fonction membre append de la classe ara::core::BasicString ([SWS_CORE_03079]) ajoute une chaîne de caractères terminée par un caractère nul du type pointeur const value_type* à la chaîne de caractères existante. La sémantique correspond au comportement du standard C++ [basic.string], où charT est remplacé par value_type. Comme valeur de retour, la fonction synchrone renvoie une référence à l'objet appelant (BasicString&), ce qui permet le chaînage d'opérations successives.

En ce qui concerne le traitement des erreurs et la sécurité vis-à-vis des exceptions, l'opération est explicitement classée comme not exception safe ([SWS_CORE_03079]). Contrairement à la surcharge avec indication de longueur [SWS_CORE_03078], qui déclenche une IsoStdLengthErrorViolation en cas de dépassement de la longueur maximale, ou aux surcharges de sous-chaînes telles que [SWS_CORE_03077] avec IsoStdOutOfRangeViolation, cette variante ne définit aucune classe de violation spécifique. Il devrait être de la responsabilité de l'appelant de s'assurer que le pointeur transmis s référence une séquence de caractères valide et terminée par un caractère nul. Question Q-4e959f75f98977eb (ouverte)

La fonction fait partie d'une famille de surcharges pour l'ajout de données dans ara::core::BasicString :

• Ajout de chaînes de caractères complètes ou partielles du même type ([SWS_CORE_03076], [SWS_CORE_03077]),
• Ajout de préfixes de pointeurs avec limitation explicite de longueur ([SWS_CORE_03078]),
• Ajout de répétitions de caractères ([SWS_CORE_03080]) ou de listes d'initialisation ([SWS_CORE_03082]),
• Traitement de plages d'itérateurs ([SWS_CORE_03081]) ainsi que de vues de chaînes ([SWS_CORE_03308], [SWS_CORE_03309]).

La fonction membre append de ara::core::BasicString ([SWS_CORE_03080]) ajoute de manière synchrone un nombre spécifié n de caractères du type value_type (paramètre c) à la chaîne de caractères existante. Elle est mise à disposition via l'en-tête ara/core/string.h et renvoie une référence à l'instance modifiée (*this), ce qui permet des appels chaînés.

Le comportement fonctionnel suit la définition du standard C++ pour [basic.string], charT étant remplacé par value_type ([SWS_CORE_03080]). Concernant la sécurité vis-à-vis des exceptions, la fonction est explicitement classée comme not exception safe ([SWS_CORE_03080]). Contrairement à d'autres surcharges telles que [SWS_CORE_03077] ou [SWS_CORE_03078], aucune violation spécifique à l'exécution (violations) telle que IsoStdOutOfRangeViolation ou IsoStdLengthErrorViolation n'est définie pour cette variante. Vraisemblablement, en cas d'erreur, la méthode ne garantit pas un état inchangé de l'instance. Question Q-15af6c12a1a342a9 (ouverte)

Dans le contexte de la concurrence et de la thread-safety, il convient de noter que les accès simultanés en écriture à la même instance de BasicString doivent vraisemblablement être synchronisés de manière externe. Question Q-1e8a1511516e4cd8 (ouverte) La fonction complète les autres surcharges de append dans ara::core::BasicString, qui couvrent l'ajout de chaînes de caractères entières ([SWS_CORE_03076]), de sous-plages ([SWS_CORE_03077]), de tampons de pointeurs ([SWS_CORE_03078], [SWS_CORE_03079]), de plages d'itérateurs ([SWS_CORE_03081]), de listes d'initialisation ([SWS_CORE_03082]) ou d'objets StringView ([SWS_CORE_03308], [SWS_CORE_03309]).

Utilisation et sémantique

La fonction membre modèle append de la classe ara::core::BasicString est fournie via le fichier d'en-tête ara/core/string.h [SWS_CORE_03081]. Elle ajoute de manière synchrone à la chaîne de caractères existante une séquence de caractères délimitée par la paire d'itérateurs first et last de la catégorie InputIterator [SWS_CORE_03081]. Le comportement fonctionnel suit alors la définition correspondante dans [basic.string] du standard C++ [SWS_CORE_03081]. Comme valeur de retour, l'opération renvoie une référence à l'objet BasicString modifié (*this) [SWS_CORE_03081].

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

Pour cette fonction, la sécurité vis-à-vis des exceptions est explicitement définie comme not exception safe [SWS_CORE_03081]. En cas d'erreur — par exemple lors de l'épuisement de la mémoire dynamique pendant l'agrandissement du tampon —, l'instance devrait, selon toute interprétation, rester dans un état invalide. Question Q-600c7dacc868877c (ouverte) Des violations AUTOSAR spécifiques telles que IsoStdOutOfRangeViolation ou IsoStdLengthErrorViolation ne sont pas définies pour cette surcharge d'itérateurs, contrairement à d'autres surcharges de la méthode [SWS_CORE_03077], [SWS_CORE_03078].

Interaction au sein du module

La fonction fait partie d'un ensemble étendu de surcharges pour l'ajout de données à ara::core::BasicString :

• Ajout de chaînes de caractères complètes ou partielles de type BasicString [SWS_CORE_03076], [SWS_CORE_03077].
• Ajout de tableaux de caractères avec indication de longueur ou de séquences de caractères terminées par un caractère nul [SWS_CORE_03078], [SWS_CORE_03079].
• Ajout répété de caractères individuels [SWS_CORE_03080] ainsi que reprise depuis std::initializer_list [SWS_CORE_03082].
• Intégration de vues de chaînes modernes via StringView ou des types de vues génériques [SWS_CORE_03308], [SWS_CORE_03309].

La variante avec itérateurs [SWS_CORE_03081] offre alors la flexibilité maximale pour l'intégration de sources de données génériques arbitraires.

La fonction membre append de la classe ara::core::BasicString ajoute de manière synchrone les caractères d'une liste d'initialisation du type std::initializer_list<value_type> à l'objet chaîne existant [SWS_CORE_03082]. Le comportement suit la sémantique de [basic.string] du standard C++ avec la différence que charT est remplacé par value_type [SWS_CORE_03082]. L'appel modifie directement l'instance et renvoie une référence à l'objet, ce qui permet le chaînage de méthodes.

Concernant le traitement des erreurs, la fonction est classée comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_03082]. À la différence de surcharges apparentées telles que [SWS_CORE_03077] ou [SWS_CORE_03078], cette variante ne définit aucune violation spécifique telle que IsoStdOutOfRangeViolation ou IsoStdLengthErrorViolation. Interprétation : si l'allocation interne de mémoire échoue, l'objet reste vraisemblablement dans un état indéfini. Question Q-169750518dc1904b (ouverte) Étant donné que l'état interne est modifié, un appel concurrent sans synchronisation externe devrait conduire à des courses de données (data races).

Dans le cadre de l'interaction au sein de ara::core::BasicString, la fonction fait partie d'un groupe d'opérations append apparentées. Elle complète des surcharges pour des chaînes de caractères entières ([SWS_CORE_03076]), des sous-plages ([SWS_CORE_03077]), des pointeurs vers des chaînes de caractères ([SWS_CORE_03078], [SWS_CORE_03079]), des caractères individuels répétés ([SWS_CORE_03080]), des plages d'itérateurs ([SWS_CORE_03081]) et des instances de StringView ([SWS_CORE_03308], [SWS_CORE_03309]).

Utilisation

La fonction membre synchrone append de la classe ara::core::BasicString ajoute les caractères d'une vue de chaîne transmise (StringView sv) à la chaîne existante [SWS_CORE_03308]. L'interface est incluse via l'en-tête #include "ara/core/string.h" [SWS_CORE_03308]. Elle renvoie une référence à l'instance appelante (BasicString &), permettant ainsi de chaîner plusieurs modifications [SWS_CORE_03308]. La sémantique fonctionnelle suit la spécification correspondante en C++ [basic.string] [SWS_CORE_03308].

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

La fonction est explicitement spécifiée dans AUTOSAR comme non sûre vis-à-vis des exceptions (« not exception safe ») [SWS_CORE_03308]. Aucun code d'erreur spécifique, message DET ou DEM, ni violation AUTOSAR explicite n'est défini pour cet appel, alors que des surcharges apparentées comme [SWS_CORE_03077] ou [SWS_CORE_03309] déclenchent une IsoStdOutOfRangeViolation en cas de dépassement d'index et [SWS_CORE_03078] déclenche une IsoStdLengthErrorViolation en cas de dépassement de longueur.

Concurrence et interaction

Étant donné que append modifie directement l'état de l'objet chaîne appelé, un accès concurrent de plusieurs threads à la même instance sans synchronisation externe ne devrait pas être thread-safe. Question Q-814665e285846c8e (ouverte) La méthode s'inscrit dans un ensemble avec d'autres variantes de append de ara::core::BasicString, qui permettent d'ajouter des instances complètes de BasicString [SWS_CORE_03076], des chaînes C [SWS_CORE_03079], des caractères uniques répétés [SWS_CORE_03080] ainsi que des plages d'itérateurs [SWS_CORE_03081] ou des listes d'initialisation [SWS_CORE_03082].

Utilisation

La fonction modèle append de la classe ara::core::BasicString ([SWS_CORE_03309]) issue du fichier d'en-tête #include "ara/core/string.h" sert à ajouter de manière synchrone une sous-plage d'un objet t à la chaîne appelante. Le comportement s'aligne sur la spécification ISO C++ [basic.string]. Le paramètre pos définit l'indice de départ dans l'objet source, tandis que n détermine le nombre maximal de caractères à ajouter (valeur par défaut npos). Une référence vers l'objet chaîne de caractères modifié (*this) est fournie comme valeur de retour. Interprétation : l'objet transmis t devrait être interprété en interne comme une vue de chaîne (string view) sv. Question Q-9752a5eeaf05b684 (ouverte)

Gestion des erreurs

AUTOSAR définit pour cette fonction un écart spécifique par rapport au standard C++ : si la position indiquée est supérieure à la taille de la plage source (pos > sv.size()), une IsoStdOutOfRangeViolation est levée au lieu de std::out_of_range ([SWS_CORE_03309]). La description sémantique de cette violation correspond à celle de std::out_of_range.

Restrictions et sécurité vis-à-vis des exceptions

L'opération est expressément classée dans la spécification comme not exception safe ([SWS_CORE_03309]). En cas d'erreurs survenues, aucune conservation stable de l'état précédent n'est donc garantie.

Interaction

La fonction complète les autres variantes d'extension de chaînes de caractères dans ara::core::BasicString. En font partie les surcharges pour les instances complètes de BasicString ([SWS_CORE_03076]) ou leurs sous-plages ([SWS_CORE_03077]), les chaînes de caractères C avec indication de longueur ([SWS_CORE_03078]) ou sous forme de pointeurs terminés par un caractère nul ([SWS_CORE_03079]), les répétitions de caractères ([SWS_CORE_03080]), les plages d'itérateurs ([SWS_CORE_03081]), les listes d'initialisation ([SWS_CORE_03082]) ainsi que des objets StringView distincts ([SWS_CORE_03308]).

La fonction membre assign de la classe ara::core::BasicString sert à affecter de manière synchrone le contenu d'une chaîne de caractères existante à l'instance appelante conformément au comportement de [basic.string] [SWS_CORE_03084]. La fonction est mise à disposition via l'en-tête ara/core/string.h et accepte une référence constante vers un objet BasicString (const BasicString &str). Comme valeur de retour, elle fournit une référence vers l'objet cible modifié (*this), ce qui permet le chaînage de méthodes [SWS_CORE_03084].

Concernant la robustesse, la fonction est explicitement spécifiée comme not exception safe [SWS_CORE_03084]. Lors des allocations dynamiques de mémoire pendant l'opération de copie, des erreurs peuvent survenir sans être interceptées par des garanties sur les exceptions ; en cas d'erreur, l'instance reste probablement dans un état indéfini. Question Q-0ddd5ac03e56490f (ouverte) Aucun code d'erreur AUTOSAR spécifique ni message vers DET ou DEM n'est prévu pour cette fonction d'affectation.

En interaction avec d'autres interfaces, assign représente la variante par copie au sein d'une famille de fonctions d'affectation. Alors que la surcharge par déplacement [SWS_CORE_03085] est déclarée comme conditionally exception safe, les autres affectations — par exemple via des sous-chaînes [SWS_CORE_03086], des vues de chaîne [SWS_CORE_03087] ou des plages d'itérateurs [SWS_CORE_03091] — partagent la propriété not exception safe. Aucune sécurité pour les threads n'étant spécifiée, un appel concurrent sur la même instance sans synchronisation externe ne devrait pas être réentrant et présenterait des risques pour les données. Question Q-37d67c851a296f55 (ouverte)

La surcharge de déplacement de la fonction membre assign selon [SWS_CORE_03085] assigne de manière synchrone à une instance existante de ara::core::BasicString le contenu de la référence rvalue str (déclarée dans le fichier d'en-tête ara/core/string.h). La fonction renvoie une référence à l'objet appelant (*this). Le comportement fonctionnel suit alors la définition correspondante dans [basic.string] du standard C++.

En ce qui concerne le traitement des erreurs et des exceptions, la méthode est déclarée comme conditionnellement sûre vis-à-vis des exceptions (conditionally exception safe) [SWS_CORE_03085]. Le déclenchement d'exceptions est exclu selon noexcept si et seulement si l'allocateur propage l'assignation par déplacement (propagate_on_container_move_assignment::value) ou si les instances d'allocateur sont toujours considérées comme égales (is_always_equal::value). Contrairement à d'autres fonctions d'assignation telles que [SWS_CORE_03086] ou [SWS_CORE_03088], qui déclenchent des violations spécifiques telles que IsoStdOutOfRangeViolation ou IsoStdLengthErrorViolation en cas de dépassement de plage ou de longueur et sont considérées comme non sûres vis-à-vis des exceptions, cette opération ne définit aucune violation AUTOSAR distincte.

En interaction avec des surcharges alternatives de BasicString::assign — par exemple pour des références lvalue constantes selon [SWS_CORE_03084], des vues via [SWS_CORE_03087] ou des tampons de chaînes de caractères selon [SWS_CORE_03089] —, la variante rvalue permet une affectation économe en ressources sans réallocation de mémoire. Interprétation : après le transfert, l'objet source str reste vraisemblablement dans un état valide mais non spécifié, comme cela est habituel pour les opérations de déplacement selon [basic.string]. Question Q-88c8157963cdd7e0 (ouverte)

La fonction membre assign de la classe ara::core::BasicString ([SWS_CORE_03086]), mise à disposition via l'en-tête ara/core/string.h, affecte de manière synchrone à l'instance actuelle une sous-partie d'une chaîne de caractères source transmise str. L'appel prend, outre la référence source str, l'indice de départ pos ainsi que, optionnellement, le nombre de caractères n, pour lequel npos est défini par défaut. Après l'affectation, une référence vers l'objet modifié (*this) est renvoyée. La sémantique fonctionnelle correspond pour l'essentiel aux prescriptions de [basic.string] ([SWS_CORE_03086]).

Concernant la gestion des erreurs, une divergence explicite existe par rapport à la norme ISO C++ : si la condition pos > str.size() est vérifiée, aucune std::out_of_range n'est déclenchée, mais une IsoStdOutOfRangeViolation est provoquée ([SWS_CORE_03086]). De plus, la fonction est expressément classée dans la spécification comme non sûre vis-à-vis des exceptions (not exception safe) ([SWS_CORE_03086]).

Dans l'ensemble des méthodes d'affectation de ara::core::BasicString, cette surcharge pour sous-chaîne complète l'affectation de chaînes complètes ([SWS_CORE_03084]), l'affectation par déplacement conditionnellement sûre vis-à-vis des exceptions ([SWS_CORE_03085]), l'affectation à partir d'un StringView ([SWS_CORE_03087]) ainsi que des opérations avec des tampons de caractères ([SWS_CORE_03088]) ou des plages d'itérateurs ([SWS_CORE_03091]).

Utilisation

La fonction membre assign pour StringView ([SWS_CORE_03087]) remplace de manière synchrone le contenu d'une instance de ara::core::BasicString par les caractères de la vue de chaîne transmise. La sémantique suit la définition correspondante dans [basic.string] de la bibliothèque standard C++. En tant que valeur de retour, la fonction fournit une référence à l'objet cible modifié (BasicString &), ce qui permet de chaîner des appels de méthode successifs. La déclaration est mise à disposition via le fichier d'en-tête #include "ara/core/string.h".

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

La fonction est désignée dans la spécification comme not exception safe ([SWS_CORE_03087]). Interprétation : si l'affectation nécessite un agrandissement de la capacité du tampon interne et que cette allocation de mémoire échoue, une exception devrait être levée sans qu'il n'y ait de garantie quant à l'état inchangé de l'instance. Question (ouverte)

Concurrence et restrictions

Interprétation : les appels de assign sur la même instance de ara::core::BasicString ne sont pas sûrs pour les threads et nécessitent une synchronisation externe en cas d'accès simultané de plusieurs threads en lecture ou en écriture. Question Q-12774d6cd363b032 (ouverte)

Interaction

La fonction enrichit le spectre d'affectation de ara::core::BasicString de vues à typage sûr. Elle coexiste aux côtés des surcharges pour les affectations par copie et par déplacement ([SWS_CORE_03084], [SWS_CORE_03085]), les sous-chaînes ([SWS_CORE_03086]), les pointeurs vers des données de caractères ([SWS_CORE_03088], [SWS_CORE_03089]), les répétitions de caractères ([SWS_CORE_03090]), les plages d'itérateurs ([SWS_CORE_03091]) et les listes d'initialiseurs ([SWS_CORE_03092]).

Utilisation

La fonction membre assign de la classe ara::core::BasicString affecte de manière synchrone à l'instance de chaîne actuelle les n premiers caractères du tableau de caractères s de type const value_type* transmis, et renvoie une référence à l'objet modifié (*this) [SWS_CORE_03088]. Le comportement fonctionnel correspond fondamentalement à la définition selon [basic.string], AUTOSAR remplaçant le type de paramètre générique charT par value_type [SWS_CORE_03088].

Gestion des erreurs et conditions limites

L'affectation est spécifiée comme non sûre vis-à-vis des exceptions (not exception safe) [SWS_CORE_03088]. Si la longueur indiquée n dépasse la taille maximale représentable max_size() (n > max_size()), la fonction déclenche la violation AUTOSAR IsoStdLengthErrorViolation au lieu de std::length_error [SWS_CORE_03088]. Interprétation : l'appelant devrait devoir s'assurer que s pointe vers au moins n caractères valides, la spécification ne définissant aucune vérification de tampon distincte. Question Q-290c36db79f27a0a (ouverte)

Interaction

La fonction est principalement adaptée aux tampons non terminés par un caractère nul ou à des sous-parties de tableaux. Elle complète la surcharge assign(const value_type* s) [SWS_CORE_03089], où la longueur est déterminée implicitement. Dans l'ensemble des classes de ara::core::BasicString, il existe d'autres surcharges d'affectation pour reprendre des chaînes de caractères existantes par copie [SWS_CORE_03084] ou déplacement [SWS_CORE_03085], pour affecter des sous-chaînes avec contrôle d'index [SWS_CORE_03086], pour reprendre à partir de StringView [SWS_CORE_03087] ainsi que pour des répétitions de caractères [SWS_CORE_03090], des plages d'itérateurs [SWS_CORE_03091] et des listes d'initialisation [SWS_CORE_03092].

La fonction membre synchrone assign de la classe ara::core::BasicString ([SWS_CORE_03089]) issue de l'en-tête ara/core/string.h remplace le contenu actuel d'un objet de chaîne de caractères par la séquence de caractères s transmise de type const value_type*. L'appel renvoie une référence vers l'objet modifié (*this). Le comportement fonctionnel suit les prescriptions du standard ISO C++ pour [basic.string], avec la déviation documentée selon laquelle le type de caractère charT est remplacé par value_type ([SWS_CORE_03089]). Interprétation : à défaut d'un paramètre de longueur distinct, le pointeur s devrait faire référence à un tableau de caractères terminé par un caractère nul. Question Q-eea79e929750c27f (ouverte)

En ce qui concerne le traitement des erreurs et la robustesse, la fonction d'assignation est classée comme non sûre vis-à-vis des exceptions (not exception safe) ([SWS_CORE_03089]). Contrairement à des surcharges apparentées telles que assign(const BasicString&, size_type, size_type) ([SWS_CORE_03086]) ou assign(const value_type*, size_type) ([SWS_CORE_03088]), aucune violation spécifique à l'exécution comme IsoStdOutOfRangeViolation ou IsoStdLengthErrorViolation n'est définie pour cette variante.

Dans le module core, la fonction fait partie d'une vaste famille de surcharges pour l'affectation de contenu. Celle-ci couvre, outre les pointeurs bruts, également les chaînes complètes ([SWS_CORE_03084]), la sémantique de déplacement ([SWS_CORE_03085]), les instances de StringView ([SWS_CORE_03087]), les caractères uniques répétés ([SWS_CORE_03090]), les plages d'itérateurs ([SWS_CORE_03091]) et les listes d'initialisation ([SWS_CORE_03092]). AUTOSAR propose également des modèles d'affectation similaires dans des types de conteneurs tels que ara::core::Vector ([SWS_CORE_01328]).

Utilisation

La fonction membre assign de la classe ara::core::BasicString (définie dans #include "ara/core/string.h") remplace de manière synchrone le contenu actuel de la chaîne de caractères par n copies consécutives du caractère c de type value_type [SWS_CORE_03090]. La sémantique correspond à la définition pour [basic.string], avec la divergence que le paramètre de type charT est remplacé par value_type [SWS_CORE_03090]. En guise de valeur de retour, la fonction renvoie une référence lvalue vers l'instance modifiée (*this), ce qui permet d'enchaîner d'autres opérations.

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

Selon la spécification, l'opération est explicitement classée comme not exception safe [SWS_CORE_03090]. À la différence d'autres surcharges qui déclenchent, en cas de dépassement de limite, des violations définies telles que IsoStdOutOfRangeViolation [SWS_CORE_03086] ou IsoStdLengthErrorViolation [SWS_CORE_03088], cette fonction ne nomme aucune violation spécifique. Si une allocation de mémoire requise échoue, il n'existe aucune garantie quant au maintien de l'état antérieur de l'objet.

Concurrence et restrictions

Dans la mesure où l'assignation modifie directement le tampon interne et qu'aucune synchronisation interne n'est spécifiée, l'accès simultané de plusieurs threads à la même instance ne devrait pas être sûr du point de vue des threads (interprétation). Question Q-50f419c4bca5c151 (ouverte) Les appels parallèles doivent être coordonnés de manière externe par l'appelant.

Interaction

La fonction complète le portefeuille d'affectations de ara::core::BasicString, qui fournit, outre des affectations par copie et par déplacement [SWS_CORE_03084], [SWS_CORE_03085] ainsi que des itérateurs et des listes d'initialiseurs [SWS_CORE_03091], [SWS_CORE_03092], également des interfaces pour des string views [SWS_CORE_03087]. Un modèle d'affectation comparable avec un nombre de répétitions existe de manière analogue pour ara::core::Vector::assign [SWS_CORE_01329].