classe ara::core::StringView

Utilisation

La fonction membre at de la classe ara::core::StringView fournit un accès synchrone en lecture à des caractères individuels ([SWS_CORE_02133]). Elle accepte comme paramètre l'index pos de type size_type et renvoie une référence constante (const_reference) sur le caractère à cette position. La fonction est spécifiée comme constexpr et noexcept, permettant ainsi aux appels d'être également évalués à la compilation.

Gestion des erreurs

Contrairement au comportement dans le standard [string.view], la fonction ne lève pas d'exception de type std::out_of_range en cas d'erreur ([SWS_CORE_02133]). Lorsque la condition pos >= size() est remplie, une IsoStdOutOfRangeViolation est déclenchée à la place. La spécification classe la fonction comme sûre vis-à-vis des exceptions (exception safe).

Concurrence et restrictions

Puisque at est déclarée comme const, l'appel ne modifie pas l'instance sous-jacente. L'appelant doit s'assurer que la chaîne de caractères référencée reste valide pour toute la durée de vie de l'objet StringView. En cas de survenue de la violation de plage IsoStdOutOfRangeViolation, l'exécution devrait être interrompue de manière contrôlée ; des routines d'interruption personnalisées peuvent être enregistrées à cet effet via AddAbortHandler ([SWS_CORE_00054]) (Interprétation). Question Q-0836f4dc6fa946a6 (ouverte)

Interaction

Le concept consistant à intercepter les dépassements de plage via IsoStdOutOfRangeViolation est appliqué de manière cohérente à travers plusieurs conteneurs dans ara::core :

• Dans ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]) et ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), at est également déclarée comme noexcept et sûre vis-à-vis des exceptions.
• En revanche, les fonctions at correspondantes dans ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]) ainsi que dans ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]) sont classées comme non sûres vis-à-vis des exceptions (not exception safe) et ne sont pas marquées comme noexcept.

Utilisation

La fonction membre compare de la classe ara::core::StringView issue de l'en-tête #include "ara/core/string_view.h" sert à la comparaison lexicographique synchrone de la vue de chaîne de caractères actuelle avec une instance s transmise de type StringView [SWS_CORE_02142]. Le comportement se conforme à l'utilisation correspondante dans [string.view] de la norme C++ [SWS_CORE_02142]. Comme valeur de retour, la fonction fournit un int qui reflète la relation relationnelle des séquences de caractères [SWS_CORE_02142].

Gestion des erreurs

La fonction est déclarée avec noexcept et spécifiée comme exception safe [SWS_CORE_02142]. Elle ne déclenche aucune exception C++. Aucun code d'erreur spécifique, erreur de développement AUTOSAR (DET) ou notification destinée au Diagnostic Event Manager (DEM) n'est prévu pour cette opération [SWS_CORE_02142].

Concurrence et contraintes

Grâce à la classification en tant que const ainsi que constexpr, l'appel peut déjà être évalué au moment de la compilation [SWS_CORE_02142]. Interprétation : comme la fonction accède en lecture à des chaînes de caractères immuables, un appel concurrent via le même StringView à partir de plusieurs threads devrait être sûr pour les threads, pour autant que les données de caractères sous-jacentes ne soient pas modifiées. Question Q-7489abeeb3fd7124 (ouverte)

Interaction

Tandis que les types de base dans ara::core tels que ErrorDomain [SWS_CORE_00137] ou ErrorCode [SWS_CORE_00571] fournissent principalement des opérateurs d'égalité binaires pour les vérifications, compare propose pour StringView une valeur de comparaison ternaire [SWS_CORE_02142].

Utilisation

La fonction membre compare de la classe ara::core::StringView effectue une comparaison lexicographique synchrone d'une sous-plage de la vue de chaîne de caractères actuelle avec une StringView s transmise [SWS_CORE_02143]. La sous-chaîne à comparer commence à l'indice pos1 et comprend une longueur maximale de n1 caractères. La valeur de retour est un int entier qui indique le résultat relationnel. Comme la fonction est déclarée comme constexpr, l'évaluation peut déjà avoir lieu au moment de la compilation [SWS_CORE_02143].

Gestion des erreurs

La sémantique se conforme aux exigences de [string.view] de la norme ISO C++, mais définit deux divergences essentielles [SWS_CORE_02143] :

• La fonction est spécifiée avec noexcept et est considérée comme sûre envers les exceptions (exception safe) [SWS_CORE_02143].
• Si l'indice de départ dépasse la longueur de la vue (pos1 > size()), aucune exception standard de type std::out_of_range n'est déclenchée, mais une IsoStdOutOfRangeViolation est provoquée [SWS_CORE_02143].

Concurrence et contraintes

Les appelants doivent s'assurer au préalable que pos1 ne dépasse pas la valeur de size() afin d'éviter une IsoStdOutOfRangeViolation [SWS_CORE_02143]. Comme compare est déclarée comme const et n'effectue aucune modification sur l'instance, l'accès concurrent en lecture depuis plusieurs threads devrait être non critique (interprétation). Question Q-be4ec80ab2529ed3 (ouverte)

La fonction membre compare de la classe ara::core::StringView ([SWS_CORE_02144], fichier d'en-tête #include "ara/core/string_view.h") sert à la comparaison lexicographique et synchrone de deux sous-chaînes de caractères. Le comportement fondamental correspond au fonctionnement dans [string.view] de la norme ISO C++, mais présente des divergences spécifiques pour AUTOSAR Adaptive [SWS_CORE_02144].

Les paramètres transmis déterminent les segments à comparer des deux séquences [SWS_CORE_02144] :

• pos1 et n1 : indice de départ et nombre maximal de caractères au sein de l'instance appelante.
• s : l'objet à comparer de type StringView.
• pos2 et n2 : indice de départ et nombre maximal de caractères au sein de l'objet s transmis.

Comme valeur de retour, la fonction fournit une valeur entière (int), qui est négative si sa propre sous-séquence est lexicographiquement plus petite, nulle en cas de correspondance et positive si elle est plus grande [SWS_CORE_02144].

En ce qui concerne la gestion des erreurs, l'implémentation s'écarte de la norme : la méthode est déclarée comme noexcept et est considérée comme sûre envers les exceptions (exception safe) [SWS_CORE_02144]. Si l'une des positions de départ se trouve en dehors de la plage valide (pos1 > size() || pos2 > s.size()), aucune exception std::out_of_range n'est levée, mais une IsoStdOutOfRangeViolation est déclenchée [SWS_CORE_02144].

Grâce aux qualificateurs constexpr et const, la fonction peut déjà être évaluée pendant la compilation [SWS_CORE_02144]. Comme aucun état interne n'est modifié, des accès concurrents en lecture à la même instance devraient être sûrs pour les threads. Question Q-a93f872ee88becc9 (ouverte)

La fonction membre compare de la classe ara::core::StringView (fichier d'en-tête #include "ara/core/string_view.h") sert à la comparaison lexicographique synchrone de la vue de chaîne actuelle avec une chaîne de caractères C terminée par un caractère nul const char* s [SWS_CORE_02145]. Comme l'opération est spécifiée en tant que constexpr, l'évaluation peut s'effectuer aussi bien au moment de l'exécution que dans le cadre d'expressions au moment de la compilation. Comme valeur de retour, la fonction renvoie une valeur entière de type int, dont le signe reflète le résultat de la comparaison de manière analogue à [string.view] : une valeur inférieure à zéro signifie que l'instance précède lexicographiquement s ; la valeur zéro indique l'égalité ; une valeur supérieure à zéro indique que l'instance suit s [SWS_CORE_02145].

En ce qui concerne la gestion des erreurs, la spécification AUTOSAR s'écarte explicitement du modèle dans [string.view] : la méthode est déclarée comme noexcept et possède la propriété exception safe [SWS_CORE_02145]. Les appels sont ainsi garantis de ne pas pouvoir lever d'exceptions C++. Aucun code d'erreur spécifique, ni retour vers le Development Error Tracer (DET) ou le Diagnostic Event Manager (DEM), n'est prévu pour cette fonction de base.

En tant que méthode qualifiée const, compare ne modifie pas l'état de l'instance ara::core::StringView et peut être appelée en lecture en toute sécurité en contexte concurrent. Lors de l'utilisation, il convient de noter que le pointeur s doit probablement pointer vers une séquence de caractères valide, car la sémantique issue de [string.view] devrait entraîner un comportement indéfini en cas de transmission d'un pointeur nul [SWS_CORE_02145]. Question Q-cff1a1f55603dbd4 (ouverte)

Utilisation

La méthode compare de la classe ara::core::StringView permet une comparaison lexicographique synchrone d'une sous-plage de la vue de chaîne de caractères avec une chaîne de caractères C terminée par un caractère nul s [SWS_CORE_02146]. Sont transmis l'indice de départ pos1, la longueur maximale n1 ainsi que le pointeur s vers la séquence de caractères à comparer. La valeur de retour de type int reflète le résultat de l'ordre relationnel de manière analogue à la bibliothèque standard : une valeur de retour inférieure à zéro, égale à zéro ou supérieure à zéro caractérise la relation lexicographique [SWS_CORE_02146].

Gestion des erreurs et conditions limites

L'opération est spécifiée comme noexcept et « exception safe » [SWS_CORE_02146]. Contrairement au comportement selon la norme C++ [string.view], un indice de départ non valide avec pos1 > size() ne déclenche pas d'exception std::out_of_range, mais entraîne une IsoStdOutOfRangeViolation [SWS_CORE_02146]. Cette violation devrait être considérée dans le contexte d'exécution AUTOSAR comme une erreur de programmation et forcer un arrêt direct de la plateforme, car les exceptions C++ régulières ne peuvent pas s'échapper au-delà des limites de noexcept. Question Q-d4ce6b496b80fdde (ouverte) Il convient en outre de s'assurer que s pointe vers une chaîne de caractères valide, car un pointeur nul provoque vraisemblablement un comportement indéfini.

concurrence

Comme compare est définie comme const et constexpr, l'état de l'instance reste inchangé [SWS_CORE_02146]. Des accès concurrents en lecture au même objet ara::core::StringView peuvent donc être exécutés en toute sécurité.

Utilisation

La fonction membre compare de la classe ara::core::StringView de l'en-tête ara/core/string_view.h effectue une comparaison lexicographique synchrone [SWS_CORE_02147]. À cette occasion, une sous-séquence de l'instance actuelle, commençant à l'indice pos1 et comportant au maximum n1 caractères, est comparée aux n2 premiers caractères du tableau externe de caractères C s. La valeur de retour entière (int) suit la sémantique de [string.view] et indique par son signe si la sous-plage propre est lexicographiquement inférieure, égale ou supérieure à la séquence de référence. En tant que méthode constexpr et const, elle ne modifie pas l'objet et peut être évaluée dès la compilation [SWS_CORE_02147].

Gestion des erreurs et conditions limites

En matière de traitement des erreurs et de sécurité vis-à-vis des exceptions, AUTOSAR définit deux écarts contraignants par rapport à la norme [SWS_CORE_02147] :

• La fonction membre est spécifiée comme noexcept et entièrement classée comme exception safe [SWS_CORE_02147].
• Si la position de départ dépasse la longueur de l'instance (pos1 > size()), aucune exception std::out_of_range n'est levée, mais une IsoStdOutOfRangeViolation est déclenchée [SWS_CORE_02147].

Interprétation : en raison de la combinaison de la garantie noexcept et de IsoStdOutOfRangeViolation, un dépassement de plage ne devrait pas pouvoir être intercepté au moyen de blocs try-catch C++ classiques, mais conduit probablement à une interruption immédiate ou à un traitement des erreurs par la plateforme. Question Q-67fb8eda4c594a06 (ouverte)

Utilisation et contexte d'appel

La fonction membre contains de la classe ara::core::StringView sert à vérifier de manière synchrone si une vue de chaîne contient une sous-chaîne spécifiée [SWS_CORE_02154]. La fonction est définie dans l'en-tête ara/core/string_view.h conformément à la sémantique du document de travail de la norme C++ N4950 ([string.view]) [SWS_CORE_02154]. En guise de paramètre, la méthode reçoit par valeur une autre instance de StringView (sv) et renvoie directement une valeur booléenne de type bool : true si la sous-séquence est présente, sinon false [SWS_CORE_02154].

Grâce à sa spécification en tant que constexpr, l'appel peut être effectué aussi bien à l'exécution que dès la compilation dans le cadre de contextes au moment de la compilation [SWS_CORE_02154].

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

Pour contains, le comportement est stipulé comme exception safe et la signature est explicitement qualifiée par noexcept [SWS_CORE_02154]. La fonction ne lève par conséquent en aucun cas d'exceptions C++ et ne renvoie aucune erreur via ara::core::Result ou ara::core::ErrorCode. Il n'existe aucun message d'erreur DET ou DEM pour cette fonction de base.

Concurrence et restrictions

En tant que fonction membre constante (const), contains ne modifie pas l'état de l'instance de StringView [SWS_CORE_02154]. Interprétation : des appels concurrents en lecture seule sur la même instance de StringView ou sur le tampon de caractères sous-jacent devraient être pleinement réentrants et sûrs pour les threads, tant que la zone mémoire référencée n'est modifiée simultanément par aucun thread. Question Q-80f1a9989a098913 (ouverte) Il n'existe pas d'exigences d'ordonnancement particulières ni d'obligations d'initialisation au-delà de la fourniture d'un StringView valide.

La fonction membre contains vérifie de manière synchrone si un caractère déterminé c est contenu au sein d'une ara::core::StringView [SWS_CORE_02155]. La fonction est déclarée dans l'en-tête ara/core/string_view.h et suit la sémantique de [string.view] issue du projet de standard C++ N4950 [SWS_CORE_02155]. Elle reçoit un caractère individuel de type char et renvoie une valeur de vérité de type bool, qui ne vaut probablement true que si le caractère est trouvé dans la zone de texte référencée [SWS_CORE_02155]. Question Q-3293fccace7af3ab (ouverte)

Concernant la gestion des erreurs, l'opération est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_02155]. Aucune exception n'est levée et aucun code d'erreur n'est signalé via DET, DEM ou les types de retour ; la non-existence du caractère est signalée de façon ordinaire par la valeur de retour booléenne.

Comme la fonction est désignée comme constexpr ainsi que const, elle peut être évaluée dès le moment de la compilation [SWS_CORE_02155]. Les appels ne modifient pas l'objet ara::core::StringView sous-jacent, raison pour laquelle des accès parallèles en lecture sur la même instance devraient probablement être sûrs en concurrence. Question Q-298dbc4d080853bc (ouverte)

Dans l'interaction des types de base du module core, contains sert à l'inspection directe de texte sur des vues de chaînes de caractères [SWS_CORE_02155]. Alors que des types tels que ara::core::Result offrent leurs propres mécanismes de vérification pour les valeurs contenues ou les erreurs – par exemple HasValue [SWS_CORE_00751] ou CheckError [SWS_CORE_00765] –, contains fonctionne de manière légère, sans allocation ni encapsulation d'erreur.

La fonction membre contains de la classe ara::core::StringView vérifie de manière synchrone si la chaîne de caractères référencée contient la séquence de caractères str transmise en paramètre [SWS_CORE_02156]. La fonction est fournie via le fichier d'en-tête ara/core/string_view.h et renvoie le résultat de la vérification sous la forme d'une valeur de retour de type bool [SWS_CORE_02156]. Grâce à sa déclaration en tant que constexpr, l'appel peut être exécuté aussi bien au moment de l'exécution que dans le cadre d'expressions évaluées à la compilation [SWS_CORE_02156].

La sémantique fonctionnelle suit la définition de [string.view] dans le Working Draft de la norme C++ N4950, mais présente un écart contraignant : la fonction est déclarée dans AUTOSAR Adaptive avec l'identifiant noexcept [SWS_CORE_02156]. En conséquence, l'opération est spécifiée comme sûre vis-à-vis des exceptions (exception safe), ce qui garantit qu'aucune exception C++ n'est déclenchée pendant l'exécution [SWS_CORE_02156]. Aucun code d'erreur AUTOSAR spécifique ni message destiné aux enregistreurs d'erreurs de développement ou de diagnostic n'est défini pour cette fonction [SWS_CORE_02156].

En tant que fonction membre constante (const), contains ne modifie pas l'instance appelante [SWS_CORE_02156]. Interprétation : pour le paramètre str, la transmission d'une chaîne de caractères valide terminée par un caractère nul devrait être présupposée, car l'interface utilise const char *str et ne prévoit aucun contrôle distinct de longueur ou d'erreur [SWS_CORE_02156]. Question Q-a2d7cd456a72a792 (ouverte)

Utilisation

La fonction membre synchrone copy de la classe ara::core::StringView ([SWS_CORE_02140]) copie une sous-chaîne dans un tampon fourni. L'accès s'effectue via le fichier d'en-tête #include "ara/core/string_view.h" :

• Paramètres : char *s référence le tableau cible, n détermine le nombre maximal de caractères à copier et pos définit la position de départ (valeur par défaut 0).
• Valeur de retour : une valeur du type size_type indiquant le nombre de caractères réellement copiés.
• Sémantique : la fonction fonctionne de manière synchrone et s'aligne sur la spécification ISO C++ [string.view] ([SWS_CORE_02140]).

Gestion des erreurs

En cas d'erreur, lorsque pos > size() est vérifié, une IsoStdOutOfRangeViolation est déclenchée ([SWS_CORE_02140]). Cela diffère du standard [string.view], qui lève std::out_of_range. Étant donné que l'interface est déclarée comme noexcept, le déclenchement de la violation devrait vraisemblablement entraîner l'arrêt direct du processus (interprétation : aucune exception C++ n'est propagée). Question Q-4ddbe4dfb002c41f (ouverte)

Concurrence et restrictions

L'opération est spécifiée comme const ainsi que noexcept et est considérée comme exception safe ([SWS_CORE_02140]). L'appelant doit s'assurer que le tableau cible s fournit suffisamment de mémoire pour au moins min(n, size() - pos) caractères, car les erreurs de plage du tampon cible ne sont pas interceptées.

Interaction

Par rapport à ara::core::BasicString::copy ([SWS_CORE_03410]), qui fonctionne avec value_type et est classée comme not exception safe, la variante dans StringView offre une garantie noexcept sûre face aux exceptions ([SWS_CORE_02140]).

La fonction membre crbegin de la classe ara::core::StringView retourne de manière synchrone un itérateur inverse constant (const_reverse_iterator) sur le premier caractère de la vue de chaîne inversée [SWS_CORE_02126]. La fonction ne prend aucun paramètre, est déclarée via le fichier d'en-tête ara/core/string_view.h et suit la sémantique standard de [string.view] [SWS_CORE_02126].

En ce qui concerne la gestion des erreurs, l'opération est définie comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_02126]. Aucun code d'erreur n'est retourné et aucun message d'erreur n'est émis via DET ou DEM, car l'appel s'exécute de manière garantie sans erreur [SWS_CORE_02126].

Grâce à sa spécification en tant que constexpr et const, la fonction peut également être appelée dans le cadre d'expressions constantes au moment de la compilation [SWS_CORE_02126]. Interprétation : des appels parallèles à crbegin sur la même instance devraient être thread-safe en concurrence, car l'opération n'effectue aucune modification sur l'objet. Question Q-ce8bc6d0753d1aa8 (ouverte)

L'interface s'intègre parfaitement dans le concept d'itérateur inter-conteneurs d'AUTOSAR Adaptive Core. Des implémentations constexpr équivalentes de crbegin se trouvent dans ara::core::Array [SWS_CORE_01260] ainsi que ara::core::Span [SWS_CORE_01978]. De plus, des conteneurs tels que ara::core::Vector [SWS_CORE_01342], ara::core::Map [SWS_CORE_01450] et ara::core::BasicString [SWS_CORE_03049] mettent également à disposition des points d'entrée const_reverse_iterator non-constexpr correspondants.

La fonction membre crend de la classe ara::core::StringView retourne un itérateur arrière constant ([SWS_CORE_02127]). L'appel s'effectue de manière synchrone et sans paramètre sur une instance existante issue de l'en-tête ara/core/string_view.h. Le const_reverse_iterator retourné marque la fin logique d'une itération inverse ; selon la référence C++ [string.view], il pointe, en tant que position sentinelle, vers l'élément théorique situé immédiatement avant le premier caractère de la chaîne (Interprétation : par analogie avec la norme C++). Question Q-5fd666f8d3eaf308 (ouverte)

Gestion des erreurs et concurrence

La fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (« exception safe ») ([SWS_CORE_02127]). Aucune exception n'est levée, aucun code d'erreur n'est retourné et aucun message DET/DEM n'est émis. En raison de la qualification constexpr, l'itérateur peut déjà être généré au moment de la compilation. En tant que pure méthode const sans effets d'état, des appels simultanés en lecture sur la même instance devraient être sûrs en concurrence (Interprétation). Question Q-207e2b9561f61d27 (ouverte)

Interaction

L'interface suit le concept d'itération uniforme de ara::core pour les structures de données séquentielles. Des spécifications connexes définissent des interfaces crend analogues :

• ara::core::Array ([SWS_CORE_01261]) et ara::core::Span ([SWS_CORE_01979]), également spécifiées comme constexpr,
• ara::core::Vector ([SWS_CORE_01343]), ara::core::Map ([SWS_CORE_01451]) et ara::core::BasicString ([SWS_CORE_03050]).

Utilisation

La fonction membre ara::core::StringView::ends_with vérifie de manière synchrone si la séquence de caractères considérée se termine par la sous-séquence transmise sv [SWS_CORE_02151]. Elle est déclarée dans le fichier d'en-tête ara/core/string_view.h et suit la sémantique standardisée du C++ conformément à [string.view] d'ISO/IEC 14882:2020 [SWS_CORE_02151]. Grâce à la désignation en tant que constexpr, la comparaison peut être évaluée dès la compilation. Comme il s'agit d'une méthode const, l'objet appelant n'est pas modifié.

Gestion des erreurs et concurrence

La spécification attribue à ends_with la propriété exception safe et la déclare comme noexcept [SWS_CORE_02151]. La fonction ne lève donc aucune exception et ne signale aucun échec, ni via des canaux d'erreur AUTOSAR tels que DET ou DEM, ni via des codes d'erreur spécifiques. En tant que pure opération de lecture sur une vue de chaîne de caractères immuable, la fonction devrait être réentrante et sûre lors d'accès simultanés en lecture sur la même instance sans mécanismes de synchronisation. Question Q-821d4d0f216694ef (ouverte)

Interaction

La méthode fait partie de la classe ara::core::StringView et est complétée par des surcharges apparentées : outre l'évaluation par rapport à un autre objet StringView, des variantes pour la vérification par rapport à un caractère unique char [SWS_CORE_02152] ainsi que par rapport à une chaîne C terminée par un caractère nul const char* [SWS_CORE_02153] sont disponibles, lesquelles sont également sûres vis-à-vis des exceptions et utilisables au moment de la compilation.

Utilisation

La fonction membre ends_with de la classe ara::core::StringView vérifie de manière synchrone si la chaîne de caractères référencée se termine par le caractère c spécifié ([SWS_CORE_02152]). Elle est déclarée via l'en-tête ara/core/string_view.h et suit le fonctionnement standardisé issu de [string.view] selon ISO/IEC 14882:2020 ([SWS_CORE_02152]). Grâce à la désignation en tant que constexpr, l'évaluation peut être effectuée aussi bien au moment de l'exécution qu'au préalable dans le cadre de la compilation ([SWS_CORE_02152]).

Traitement des erreurs et comportement à l'exécution

L'interface garantit une sécurité totale face aux exceptions (« exception safe ») et est pourvue du spécificateur noexcept ([SWS_CORE_02152]). Elle ne lève par conséquent jamais d'exceptions et n'utilise pas de messages d'erreur via DET ou DEM. En présence d'une chaîne de caractères vide, la vérification renvoie toujours le résultat booléen false.

Concurrence et interaction

Comme ends_with est définie comme une pure opération const sans effets d'état, un accès simultané en lecture depuis plusieurs threads à la même instance ne devrait pas poser de problème (interprétation). Question Q-b3a5dccbd8ff638a (ouverte) En plus du caractère individuel, ara::core::StringView propose deux surcharges supplémentaires pour les vérifications de terminaison : la comparaison avec un autre StringView ([SWS_CORE_02151]) ainsi que la vérification par rapport à une chaîne C terminée par un caractère nul de type const char* ([SWS_CORE_02153]). Les deux variantes sont également exécutées de manière synchrone, constexpr et noexcept ([SWS_CORE_02151], [SWS_CORE_02153]).

La fonction membre ends_with de la classe ara::core::StringView vérifie de manière synchrone si la séquence de caractères considérée se termine par une chaîne de caractères spécifique [SWS_CORE_02153]. La fonction accepte un pointeur const char* str comme paramètre et fournit une valeur de retour de type bool [SWS_CORE_02153]. Grâce à la déclaration en tant que constexpr, l'évaluation peut s'effectuer aussi bien à l'exécution que dès la compilation [SWS_CORE_02153]. La sémantique fonctionnelle suit la définition de la section [string.view] de la norme ISO/IEC 14882:2020 [SWS_CORE_02153].

Concernant le traitement des erreurs, la fonction est déclarée comme noexcept et classée comme sûre vis-à-vis des exceptions (exception safe), raison pour laquelle aucune exception C++ n'est levée [SWS_CORE_02153]. Aucun code d'erreur AUTOSAR spécifique ni message d'erreur vers DET ou DEM n'est prévu pour cette fonction utilitaire.

Interprétation : lors de l'appel, le paramètre str devrait devoir pointer vers une chaîne de caractères valide et terminée par un caractère nul, car aucun paramètre de longueur supplémentaire n'est transmis [SWS_CORE_02153]. Question Q-d6d076a1a2ab7dce (ouverte) Comme la méthode est qualifiée comme const et ne modifie aucun état interne, l'accès simultané en lecture à la même instance est sûr.

La fonction est disponible via le fichier d'en-tête #include "ara/core/string_view.h" dans la portée de ara::core::StringView [SWS_CORE_02153]. Elle complète des surcharges apparentées de ends_with qui acceptent, à la place d'une chaîne C, un objet StringView [SWS_CORE_02151] ou un caractère unique char [SWS_CORE_02152].

La fonction membre find de la classe ara::core::StringView recherche de manière synchrone la première occurrence de la sous-chaîne transmise s à partir de la position de départ pos, conformément au comportement défini dans [string.view] [SWS_CORE_02157]. La fonction est définie comme constexpr et const, ce qui lui permet également d'être appelée au moment de la compilation et sur des instances immuables [SWS_CORE_02157].

En ce qui concerne le traitement des erreurs, la méthode est déclarée comme noexcept et classée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_02157] ; aucun code d'erreur spécifique ni message DET ou DEM n'est prévu. Étant donné que l'exécution ne modifie pas l'état de l'objet, un accès simultané en lecture par plusieurs threads d'exécution sur la même instance de StringView devrait être autorisé sans synchronisation supplémentaire. Question Q-e27507133b5a4e20 (ouverte)

Au sein de ara::core::StringView, cette fonction est complétée par d'autres surcharges de recherche pour des caractères uniques de type char [SWS_CORE_02158] ainsi que des chaînes de caractères C [SWS_CORE_02159], [SWS_CORE_02160]. En interaction avec d'autres conteneurs, ara::core::BasicString fournit une fonction de recherche comparable pour StringView [SWS_CORE_03315], tandis que la fonction find dans ara::core::Map sert à la recherche de clés et renvoie des itérateurs [SWS_CORE_01490].

Utilisation et paramètres

La fonction membre synchrone find de la classe ara::core::StringView recherche à partir de la position d'index pos la première occurrence du caractère c ([SWS_CORE_02158]). Elle est incluse via le fichier d'en-tête #include "ara/core/string_view.h" et renvoie comme valeur de retour l'index de l'emplacement trouvé, de type size_type. Si le caractère n'est pas trouvé, la valeur npos devrait être renvoyée conformément à la référence à [string.view]. Question Q-60ea50d6f006004f (ouverte)

Gestion des erreurs et concurrence

La fonction est déclarée avec noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_02158]). Grâce à sa désignation comme constexpr et const, elle est adaptée aux expressions constantes au moment de la compilation et ne modifie pas l'objet sous-jacent. Des accès concurrents en lecture à la même instance sont probablement réentrants et thread-safe, tant que la chaîne de caractères référencée reste inchangée en mémoire. Question (ouverte)

Interaction et alternatives

La méthode complète d'autres surcharges de find dans ara::core::StringView, qui recherchent des sous-chaînes ([SWS_CORE_02157]) ou des séquences de pointeurs ([SWS_CORE_02159], [SWS_CORE_02160]). Contrairement à la recherche basée sur les caractères dans ara::core::BasicString ([SWS_CORE_03324]), qui est classée comme not exception safe, cette variante garantit une absence totale d'exceptions. Elle se distingue en outre de la recherche basée sur des clés dans ara::core::Map ([SWS_CORE_01490]).

Utilisation

La fonction membre find de la classe ara::core::StringView ([SWS_CORE_02159]) sert à la recherche synchrone d'une séquence de caractères au sein de la vue de chaîne. Elle est fournie via le fichier d'en-tête ara/core/string_view.h. La fonction prend en argument un pointeur s vers un tableau de caractères, une position de départ pos de type size_type ainsi que le nombre de caractères à rechercher n, et renvoie la position trouvée sous la forme size_type. Interprétation : selon la sémantique référencée dans [string.view], s devrait pointer vers un tableau comportant au moins n caractères et, si la recherche échoue, la valeur npos devrait être renvoyée. Question Q-e7f54bb1b42a99d8 (ouverte)

Gestion des erreurs et concurrence

La méthode est déclarée comme noexcept et spécifiée comme exception safe ([SWS_CORE_02159]). Les états d'erreur ne sont donc pas signalés par des exceptions C++. Comme la fonction est définie comme const et constexpr, elle ne modifie pas l'instance et convient aux évaluations à la compilation ainsi qu'aux accès simultanés en lecture.

Interaction

Au sein de ara::core::StringView, la fonction complète d'autres surcharges de recherche :

• Recherche d'une StringView ([SWS_CORE_02157]) ou d'un caractère unique ([SWS_CORE_02158]),
• Recherche à l'aide d'une chaîne C terminée par un caractère nul ([SWS_CORE_02160]), pour laquelle aucune longueur explicite n n'est indiquée.

Par rapport à la signature correspondante dans ara::core::BasicString ([SWS_CORE_03409]), qui est déclarée comme not exception safe et ne garantit pas noexcept, la variante dans StringView ([SWS_CORE_02159]) offre une sécurité stricte vis-à-vis des exceptions sans surcoût d'allocation.

Utilisation

La fonction membre synchrone find de la classe ara::core::StringView ([SWS_CORE_02160]) de l'en-tête #include "ara/core/string_view.h" recherche la première occurrence de la chaîne C s indiquée à partir de la position de départ pos. Le comportement fonctionnel suit la norme C++ [string.view], mais s'en écarte par la désignation explicite comme noexcept ([SWS_CORE_02160]).

Gestion des erreurs

La fonction est définie comme exception safe et garantit l'absence totale d'exceptions ([SWS_CORE_02160]). Aucun code d'erreur spécifique ni notification à DET ou DEM n'existe. Interprétation : si la chaîne recherchée n'est pas présente, l'échec de la recherche devrait être indiqué par la valeur de retour npos, de manière analogue au comportement standard de [string.view]. Question Q-febde79f1c992c2a (ouverte)

Concurrence et contraintes

Comme find est déclarée comme constexpr et const ([SWS_CORE_02160]), l'appel ne modifie pas l'état de l'objet StringView et peut être évalué dès la compilation. Interprétation : les accès en lecture concurrents à travers plusieurs threads devraient être réentrants et sûrs pour la concurrence sans mesures de synchronisation supplémentaires. Question (ouverte)

Interaction

Au sein de ara::core::StringView, il existe d'autres surcharges de find pour les paramètres StringView ([SWS_CORE_02157]), les caractères uniques ([SWS_CORE_02158]) ainsi que les sous-chaînes avec restriction explicite de longueur n ([SWS_CORE_02159]). Contrairement aux opérations de recherche de chaîne C analogues dans ara::core::BasicString ([SWS_CORE_03408], [SWS_CORE_03409]), classées comme not exception safe, l'implémentation dans ara::core::StringView garantit une sécurité totale vis-à-vis des exceptions ([SWS_CORE_02160]).

Utilisation

La fonction membre find_first_not_of de la classe ara::core::StringView ([SWS_CORE_02173]) sert à la recherche synchrone du premier caractère au sein de la vue de chaîne de caractères qui n'est pas contenu dans le StringView s transmis. La position de départ pos peut être indiquée de manière optionnelle comme second paramètre (valeur par défaut pos=0). La fonction renvoie la position d'index trouvée sous forme de size_type. Le comportement s'aligne ici sur la sémantique correspondante dans [string.view]. Interprétation : si aucun caractère différent n'est trouvé, la fonction devrait, conformément à cette sémantique standard, renvoyer la valeur npos. Question Q-8f55419868615e5a (ouverte)

Gestion des erreurs et concurrence

La fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (« exception safe ») ([SWS_CORE_02173]). Aucune exception n'est levée et aucun message d'erreur spécifique via DET ou DEM n'est défini. Grâce aux qualificateurs const et constexpr, l'appel peut s'effectuer sans effet secondaire au moment de la compilation ou en parallèle sur des objets non modifiés.

Interaction et surcharges

Au sein de ara::core::StringView, la fonction est complétée par d'autres surcharges noexcept :

• Recherche d'un caractère différent d'un caractère individuel char c ([SWS_CORE_02174]).
• Recherche à l'aide d'une chaîne C const char *s avec limitation de longueur n ([SWS_CORE_02175]) ou à partir d'une position de départ ([SWS_CORE_02176]).

Un modèle de recherche similaire existe pour ara::core::BasicString, notamment avec StringView ([SWS_CORE_03319]) et BasicString ([SWS_CORE_03337]). Contrairement à StringView, les surcharges qui s'y trouvent pour les pointeurs et les caractères ([SWS_CORE_03338], [SWS_CORE_03339], [SWS_CORE_03340]) sont classées comme non sûres vis-à-vis des exceptions.

La fonction membre find_first_not_of de la classe ara::core::StringView détermine de manière synchrone la position du premier caractère au sein de la séquence de caractères qui est différent du caractère transmis c [SWS_CORE_02174]. La recherche commence par défaut au début de la vue ou à partir du décalage facultatif pos. Par référence à la norme [string.view], la fonction renvoie probablement l'index basé sur zéro de type size_type du caractère trouvé ou la valeur npos si aucun caractère divergent n'existe. Question Q-9f3eeedf35e475e7 (ouverte)

En ce qui concerne le traitement des erreurs, la fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_02174]. Elle ne lève ainsi aucune exception, n'utilise aucun message DET ou DEM et signale l'absence de correspondance d'un caractère uniquement via sa valeur de retour.

En tant que méthode constexpr et const, find_first_not_of peut être évaluée dès la compilation et garantit un accès en lecture sans état et sans effet secondaire au tableau de caractères sous-jacent. Des appels concurrents sur la même instance de StringView sont donc réentrants et sûrs sans synchronisation supplémentaire.

La fonction fait partie d'une famille d'opérations de recherche dans ara::core::StringView et complète les surcharges de recherche de sous-séquences divergentes au moyen de StringView [SWS_CORE_02173] ainsi que de paires pointeur-longueur ou de chaînes C terminées par un caractère nul [SWS_CORE_02175] [SWS_CORE_02176]. Un équivalent fonctionnel pour les chaînes de caractères modifiables existe dans ara::core::BasicString [SWS_CORE_03340], qui, contrairement à StringView, est déclaré comme non sûr vis-à-vis des exceptions.

La fonction membre find_first_not_of de la classe ara::core::StringView sert, conformément à [SWS_CORE_02175], à trouver de manière synchrone le premier caractère au sein de la chaîne de caractères qui n'apparaît pas dans une séquence de caractères prédéfinie. Le comportement correspond alors fondamentalement à l'utilisation dans [string.view], avec la dérogation documentée selon laquelle la fonction est déclarée comme noexcept [SWS_CORE_02175]. Interprétation : par la référence à [string.view], les paramètres s, pos et n devraient limiter la recherche, à partir de la position pos, aux n premiers caractères du tableau s [SWS_CORE_02175]. Question Q-745f5bc9246c11a2 (ouverte)

Utilisation et traitement des erreurs

La fonction est définie comme constexpr et const, est mise à disposition via le fichier d'en-tête #include "ara/core/string_view.h" et renvoie un index de type size_type [SWS_CORE_02175]. La spécification classe la méthode comme exception safe [SWS_CORE_02175]. Comme elle est spécifiée comme noexcept, elle ne lève aucune exception ; aucun code d'erreur ni message vers DET ou DEM n'est défini [SWS_CORE_02175].

Interaction et alternatives

Dans ara::core::StringView, des surcharges apparentées sont disponibles pour différents motifs de recherche :

• Recherche via une autre vue de chaîne de caractères StringView conformément à [SWS_CORE_02173],
• Recherche de la première divergence par rapport à un caractère unique c conformément à [SWS_CORE_02174] et
• Recherche à l'aide d'un pointeur terminé par un caractère nul const char *s sans indication explicite de longueur conformément à [SWS_CORE_02176].

Contrairement à la signature structurellement similaire dans ara::core::BasicString [SWS_CORE_03338], qui est classée comme not exception safe et ne dispose pas de noexcept, la variante dans StringView offre une sécurité totale vis-à-vis des exceptions [SWS_CORE_02175].

La fonction membre find_first_not_of de la classe ara::core::StringView ([SWS_CORE_02176]) issue de l'en-tête ara/core/string_view.h recherche de manière synchrone, à partir de la position de départ pos, le premier caractère qui n'apparaît pas dans la chaîne de caractères s. Le comportement correspond à la définition de [string.view], mais diffère par la désignation explicite en tant que noexcept ([SWS_CORE_02176]). Interprétation : de la référence à la norme [string.view], il devrait résulter que s doit pointer vers un tableau de caractères valide et terminé par un caractère nul, et qu'en cas d'échec, npos est renvoyé. Question Q-aa48a331975274a1 (ouverte)

En ce qui concerne le traitement des erreurs, la fonction est spécifiée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_02176]). Aucune exception n'est levée ; les messages d'erreur d'exécution via les mécanismes AUTOSAR tels que DET ou DEM ne sont pas définis pour cette fonction dans le payload.

En raison de sa qualification comme constexpr et const ([SWS_CORE_02176]), l'opération de recherche ne modifie pas l'état de l'objet StringView. Elle est réentrante et peut être exécutée dans n'importe quel thread ainsi que dès la compilation dans des expressions constantes.

En interaction avec des interfaces apparentées, la fonction complète d'autres surcharges au sein de ara::core::StringView, notamment pour la recherche avec un StringView ([SWS_CORE_02173]), un caractère unique char ([SWS_CORE_02174]) ou un tampon avec limitation de longueur n ([SWS_CORE_02175]). Contrairement aux surcharges basées sur des pointeurs dans ara::core::BasicString ([SWS_CORE_03338], [SWS_CORE_03339]), qui sont classées comme not exception safe, cette variante sur StringView garantit une sécurité totale vis-à-vis des exceptions.

La fonction membre find_first_of de la classe ara::core::StringView ([SWS_CORE_02165]) recherche de manière synchrone dans une séquence de caractères, à partir de l'index pos, la première occurrence de n'importe quel caractère issu de la vue de chaîne transmise s. La méthode retourne la position trouvée sous forme d'index de type size_type.

Selon la spécification, la fonction est déclarée comme noexcept et classée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CORE_02165]). Elle ne déclenche aucune exception et ne signale aucune erreur à DET ou DEM. Interprétation : si aucun caractère correspondant n'est trouvé ou si l'index de départ se situe en dehors de la plage valide, le résultat devrait correspondre à la valeur npos, par analogie avec la sémantique standard de [string.view]. Question Q-ad877979579b5bd1 (ouverte)

Comme find_first_of est spécifiée comme const, l'appel n'effectue aucune modification d'état ([SWS_CORE_02165]). Des accès concurrents en lecture sur la même instance sont possibles sans synchronisation supplémentaire. Grâce à la désignation comme constexpr, la recherche peut en outre être évaluée au moment de la compilation.

Dans le module core, d'autres surcharges existent pour ara::core::StringView, notamment pour des caractères individuels ([SWS_CORE_02166]), des pointeurs avec un nombre explicite de caractères ([SWS_CORE_02167]) ainsi que des chaînes terminées par zéro ([SWS_CORE_02168]). Dans la classe ara::core::BasicString, une surcharge comparable pour StringView est disponible avec [SWS_CORE_03317] ; à la différence de StringView, les fonctions de recherche basées sur des pointeurs y sont toutefois déclarées comme non sûres vis-à-vis des exceptions ([SWS_CORE_03330]).

Utilisation

La fonction membre find_first_of de la classe ara::core::StringView sert à la recherche synchrone de la première occurrence d'un caractère au sein de la chaîne de caractères référencée [SWS_CORE_02166]. Elle est disponible via l'en-tête ara/core/string_view.h et prend en charge le caractère recherché c ainsi que facultativement la position de départ pos, qui est définie par défaut sur 0. La fonction renvoie l'index de l'occurrence trouvée de type size_type conformément au comportement décrit dans [string.view] [SWS_CORE_02166]. En tant que méthode constexpr, elle peut être exécutée aussi bien à l'exécution que pendant la compilation.

Gestion des erreurs

La fonction est déclarée comme noexcept et explicitement classée comme sûre vis-à-vis des exceptions (« exception safe ») [SWS_CORE_02166]. Aucune exception n'est levée, et la spécification ne définit aucun code d'erreur spécifique ni message vers le suivi des erreurs de développement (DET) ou la gestion de la mémoire des défauts (DEM).

Concurrence et restrictions

En tant que fonction membre constante (const), l'appel ne modifie pas l'instance de ara::core::StringView [SWS_CORE_02166]. Interprétation : des appels parallèles en lecture sur le même objet depuis plusieurs threads devraient donc être réentrants et sûrs en environnement concurrent, tant que le tampon de caractères sous-jacent reste inchangé. Question Q-b86dddc1a54a05e1 (ouverte)

Interaction

La fonction fait partie des interfaces de recherche de ara::core::StringView. En plus de la recherche de caractères uniques, il existe des surcharges analogues, également spécifiées comme noexcept, pour des sous-chaînes au moyen de StringView [SWS_CORE_02165] ainsi que des représentations par pointeur [SWS_CORE_02167], [SWS_CORE_02168]. Par opposition, la classe ara::core::BasicString déclare des surcharges apparentées pour caractères uniques [SWS_CORE_03332] et pointeurs [SWS_CORE_03330], [SWS_CORE_03331] sans noexcept et les classe comme non sûres vis-à-vis des exceptions (« not exception safe »), tandis que les variantes de chaîne avec BasicString [SWS_CORE_03329] et StringView [SWS_CORE_03317] restent sûres vis-à-vis des exceptions.

La fonction membre find_first_of de la classe ara::core::StringView ([SWS_CORE_02167]) du fichier d'en-tête #include "ara/core/string_view.h" recherche de manière synchrone la première occurrence d'un caractère issu de la séquence de caractères s à partir de la position pos. Le paramètre n limite ici le nombre de caractères à prendre en compte du pointeur transmis. La fonction renvoie la position trouvée sous la forme size_type ; si aucun caractère n'est trouvé, la valeur npos devrait être renvoyée conformément à [string.view]. Question Q-eac57a47043e5b33 (ouverte)

Pour le contexte d'appel et le traitement des erreurs, les exigences suivantes s'appliquent :

• Sécurité vis-à-vis des exceptions et évaluation au moment de la compilation : la méthode est définie comme constexpr et const. En dérogation à la norme [string.view], elle est explicitement déclarée avec noexcept et spécifiée comme sûre vis-à-vis des exceptions (« exception safe ») ([SWS_CORE_02167]). Aucune exception n'est déclenchée et aucun code d'erreur n'est signalé.
• Surcharges apparentées dans StringView : des variantes complémentaires pour les pointeurs de chaîne de caractères sans limitation de longueur ([SWS_CORE_02168]), pour les objets ara::core::StringView ([SWS_CORE_02165]) ainsi que pour les caractères uniques ([SWS_CORE_02166]) sont fournies, qui sont également noexcept.
• Distinction par rapport à BasicString : contrairement à la surcharge correspondante dans ara::core::BasicString ([SWS_CORE_03330]), qui est répertoriée comme non sûre vis-à-vis des exceptions (« not exception safe ») et sans noexcept, l'implémentation de StringView garantit une absence totale d'exceptions ([SWS_CORE_02167]).

Utilisation

La fonction membre find_first_of de la classe ara::core::StringView issue de l'en-tête ara/core/string_view.h parcourt de manière synchrone la vue de caractères à partir de la position pos à la recherche de la première occurrence de tout caractère de la chaîne de caractères s [SWS_CORE_02168]. Elle renvoie l'index correspondant sous la forme size_type comme valeur de retour. Grâce à sa spécification en tant que constexpr, cette opération de recherche peut déjà être exécutée au moment de la compilation [SWS_CORE_02168].

Gestion des erreurs et concurrence

La fonction est déclarée comme noexcept et spécifiée comme sûre face aux exceptions (exception safe) [SWS_CORE_02168]. Il n'existe pas de codes d'erreur spécifiques ni de notifications au DET ou au DEM. Comme la méthode ne modifie pas l'état de l'instance (const), l'accès simultané en lecture à partir de plusieurs threads est sûr. Interprétation : la signature ne prévoyant aucun paramètre de longueur, l'appelant devrait être tenu de transmettre une chaîne C valide terminée par un caractère nul à s afin d'éviter tout comportement indéfini. Question Q-6b692ff18063aef5 (ouverte)

Interaction

Au sein de ara::core::StringView, la fonction complète les surcharges pour StringView [SWS_CORE_02165], les caractères uniques [SWS_CORE_02166] ainsi que les séquences de caractères avec limite explicite de longueur n [SWS_CORE_02167], qui sont toutes définies comme constexpr et noexcept. Contrairement aux fonctions analogues de recherche par pointeur dans ara::core::BasicString, classées comme non sûres vis-à-vis des exceptions (not exception safe) [SWS_CORE_03330], [SWS_CORE_03331], l'implémentation dans ara::core::StringView garantit une absence totale d'exceptions [SWS_CORE_02168].