classe ara::core::Bitset

La fonction membre [SWS_CORE_01744] appartient à la classe ara::core::Bitset et est fournie via le fichier d'en-tête #include "ara/core/bitset.h". La fonction possède la signature bool all () const noexcept;, ne prend aucun paramètre et renvoie de manière synchrone une valeur booléenne. Selon la spécification, la sémantique s'inspire de l'utilisation correspondante dans [bitset] ; interprétation : la méthode vérifie probablement si tous les bits de l'instance sont définis (présentent la valeur true). Question Q-a4f0f8970bd2c9bb (ouverte)

Concernant 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_01744]. Comme aucun état d'erreur n'est signalé et que l'exécution se déroule de façon garantie sans erreur, les codes d'erreur de ara::core::CoreErrc ne s'appliquent pas ici.

Pour le contexte d'appel et la concurrence, les conditions aux limites suivantes s'appliquent :

• L'opération est déclarée comme const et ne modifie pas l'état de l'objet ara::core::Bitset appelant [SWS_CORE_01744].
• Des accès simultanés en lecture via plusieurs threads devraient être autorisés sans synchronisation, tant qu'aucun autre thread ne modifie la même zone mémoire en écriture. Question Q-d9f1f92a120128b5 (ouverte)

La fonction membre any() de ara::core::Bitset sert à interroger de manière synchrone l'état d'occupation des bits gérés dans le bitset [SWS_CORE_01745]. Selon la spécification, le comportement se conforme à l'utilisation correspondante du modèle de classe ISO C++ [bitset] [SWS_CORE_01745]. Interprétation : la fonction renvoie true si au moins un bit est activé, et false si tous les bits sont désactivés. Question Q-20c2aaf905d4a338 (ouverte)

Concernant l'utilisation, le contexte d'exécution et le comportement en cas d'erreur, les dispositions suivantes s'appliquent :

• Appel et paramètres : la méthode est appelée sans paramètre sur une instance existante, initialisée par exemple au préalable via le constructeur [SWS_CORE_01749]. L'appel s'effectue de manière synchrone et renvoie directement le résultat du test sous forme de bool [SWS_CORE_01745].
• Gestion des erreurs : la fonction est déclarée comme noexcept et classifiée comme sûre envers les exceptions (exception safe) [SWS_CORE_01745]. Aucun code d'erreur ni message DET/DEM n'est généré ; un échec de l'opération n'est pas prévu dans la norme AUTOSAR.
• Concurrence : en raison de la qualification const, la méthode ne modifie pas l'instance [SWS_CORE_01745]. Des accès parallèles en lecture à la même instance sont vraisemblablement sûrs, tandis que les accès concurrents en écriture doivent être synchronisés par l'appelant. Question Q-34893675aa85baf1 (ouverte)

Dans le contexte du module de core, any() fournit une fonction d'inspection fondamentale pour les bitsets, qui interagit de manière transparente avec les mécanismes d'initialisation et de stockage de ara::core::Bitset [SWS_CORE_01745], [SWS_CORE_01749].

Utilisation et sémantique

La fonction membre count est appelée de manière synchrone et sans paramètre sur une instance de ara::core::Bitset ([SWS_CORE_01740]). Elle est déclarée dans l'en-tête #include "ara/core/bitset.h" et fournit le résultat du comptage sous la forme d'une valeur de retour de type std::size_t ([SWS_CORE_01740]). Le comportement fonctionnel suit la référence [bitset] ([SWS_CORE_01740]) ; la valeur devrait donc correspondre au nombre total de bits définis. Question Q-36c593b234f55695 (ouverte)

Gestion des erreurs et concurrence

La fonction est spécifiée comme noexcept et est considérée comme exception safe ([SWS_CORE_01740]). Aucune exception n'est levée et aucun code d'erreur n'est retourné, et aucun message à l'attention de DET ou DEM n'est prévu pour cet élément. Comme count est déclarée en tant que fonction membre constante (const) ([SWS_CORE_01740]), l'appel ne modifie pas l'état de l'objet. Les accès en lecture parallèles à la même instance devraient donc pouvoir être exécutés de façon concurrente, pour autant qu'aucun accès concurrent en écriture n'ait lieu. Question Q-073bc3bbcb918763 (ouverte)

Interaction et délimitation

Dans l'espace de noms ara::core, la fonction doit être clairement distinguée d'autres éléments :

• Dans ara::core::Map, count sert à déterminer les clés présentes ([SWS_CORE_01494], [SWS_CORE_01495]), mais est classé comme not exception safe.
• Dans ara::core::Span ainsi que dans la fonction factory ara::core::MakeSpan, count ne désigne pas un nom de méthode, mais un paramètre formel destiné à restreindre des plages d'éléments ([SWS_CORE_01942], [SWS_CORE_01962], [SWS_CORE_01964], [SWS_CORE_01966], [SWS_CORE_01990]).

Utilisation

La fonction membre flip() de la classe ara::core::Bitset inverse de manière synchrone l'état de tous les bits de l'instance conformément au comportement de [bitset] [SWS_CORE_01730]. La fonction est mise à disposition via l'en-tête #include "ara/core/bitset.h", ne prend aucun paramètre et renvoie une référence lvalue sur l'objet modifié (Bitset<N>&), ce qui permet le chaînage d'opérations [SWS_CORE_01730].

Gestion des erreurs et sécurité vis-à-vis 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_01730]. Aucune exception C++ n'est levée et aucun code d'erreur n'est renvoyé ; l'exécution devrait donc toujours se dérouler sans erreur. Question Q-df762b6329a2c0d4 (ouverte)

Interaction

Le module core définit des variantes connexes pour la manipulation de bits :

• La méthode surchargée flip(std::size_t pos) sert à inverser de manière ciblée un bit individuel à l'index pos [SWS_CORE_01731]. À la différence de la forme sans paramètre, elle renvoie un Result<Bitset<N>&> et signale les positions non valides via IsoStdOutOfRangeViolation [SWS_CORE_01731].
• Via la classe de référence ara::core::Bitset<N>::reference, la fonction membre flip() est disponible pour inverser un bit individuel référencé et renvoyer une reference& [SWS_CORE_01712].

La fonction membre flip de la classe ara::core::Bitset inverse de manière synchrone l'état du bit à la position transmise pos [SWS_CORE_01731]. Elle est définie dans l'en-tête #include "ara/core/bitset.h" et s'oriente d'après le comportement de std::bitset::flip, tout en présentant des écarts fonctionnels spécifiques [SWS_CORE_01731].

La fonction est déclarée comme noexcept ainsi que exception safe et renvoie en cas de succès une référence sur le bitset modifié au sein d'un Result<Bitset<N>&> [SWS_CORE_01731]. Si le paramètre pos ne correspond à aucune position de bit valide, la violation IsoStdOutOfRangeViolation est déclenchée au lieu d'une exception C++ telle que std::out_of_range [SWS_CORE_01731].

En ce qui concerne la concurrence, en l'absence de synchronisation documentée, les appels simultanés sur la même instance de bitset ne devraient pas être thread-safe et doivent être coordonnés de manière externe. Question Q-de73bb65d6aab12c (ouverte)

Dans le module core, la fonction complète d'autres opérations apparentées : pour inverser de manière synchrone tous les bits d'une instance, la surcharge sans paramètre flip() est fournie [SWS_CORE_01730], tandis que pour les objets de référence de bit, la méthode ara::core::Bitset::reference::flip() est disponible [SWS_CORE_01712].

Utilisation

La fonction membre none de la classe ara::core::Bitset sert à interroger l'état d'occupation de la séquence de bits [SWS_CORE_01746]. La méthode nécessite l'inclusion de l'en-tête ara/core/bitset.h et possède la signature bool none () const noexcept; [SWS_CORE_01746]. L'appel s'effectue de manière synchrone et sans paramètre sur une instance existante. La spécification renvoie, en ce qui concerne le comportement, à l'utilisation correspondante dans [bitset] [SWS_CORE_01746] ; interprétation : la méthode devrait renvoyer true si et seulement si aucun bit n'est activé au sein de la séquence de bits (c'est-à-dire que tous les bits sont false), et sinon false. Question Q-de8593251c7748d5 (ouverte)

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

Pour none, aucun code d'erreur ni état d'erreur distinct n'est défini. Conformément à la spécification, la fonction est déclarée comme noexcept et possède la classification sûre envers les exceptions (exception safe) [SWS_CORE_01746]. En cas d'erreur ou pendant l'exécution, aucune exception C++ ne survient donc.

Concurrence et restrictions

Puisque none est déclarée comme const [SWS_CORE_01746], l'appel de la méthode ne modifie pas l'état interne de l'objet. Des appels de lecture parallèles sur le même objet Bitset devraient donc être non critiques sur le plan de la concurrence et réentrants, tant qu'aucune modification concurrente en écriture n'a lieu sur la même instance. Question Q-cf92e9abf57e9678 (ouverte)

La fonction membre reset() réinitialise l'état d'une instance de ara::core::Bitset conformément à la spécification [SWS_CORE_01727]. La fonction est fournie via le fichier d'en-tête #include "ara/core/bitset.h" et possède la signature Bitset<N>& reset() noexcept;.

Utilisation et sémantique

La fonction ne prend aucun paramètre et s'exécute de manière synchrone sur l'objet appelant. Grâce au renvoi spécifié vers l'usage habituel dans [bitset], l'appel devrait réinitialiser tous les bits contenus à false (ou 0) et renvoyer une référence vers sa propre instance de bitset (*this), ce qui permet le chaînage de méthodes. Question Q-89116316a65e0772 (ouverte)

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

Conformément à [SWS_CORE_01727], la fonction est déclarée comme noexcept et possède la classification « exception safe ». Contrairement à la surcharge paramétrée, aucune vérification d'index n'étant requise, aucun état d'erreur ni code d'erreur ne survient avec la variante sans paramètre.

Interaction et délimitation

• Dans la même portée ara::core::Bitset se trouve la surcharge reset(std::size_t pos) selon [SWS_CORE_01728]. Celle-ci réinitialise de manière ciblée un seul bit, mais fournit un Result<Bitset<N>&> et signale une IsoStdOutOfRangeViolation si pos est invalide.
• Des fonctions portant le même nom existent également dans le module core pour ara::core::Optional selon [SWS_CORE_01136] et ara::core::Optional<T&> selon [SWS_CORE_01165] de #include "ara/core/optional.h", lesquelles rejettent la valeur contenue et présentent le type de retour void.

La fonction membre reset de la classe ara::core::Bitset réinitialise de manière synchrone un bit individuel à la position indiquée pos à la valeur 0 [SWS_CORE_01728]. La fonction suit le comportement de std::bitset, mais présente deux divergences majeures : elle est déclarée comme noexcept et renvoie le résultat dans un Result<Bitset<N>&> afin de représenter les situations d'erreur sans exceptions C++ [SWS_CORE_01728].

Gestion des erreurs

Si l'index pos transmis ne correspond à aucune position de bit valide au sein du bitset, la violation IsoStdOutOfRangeViolation est déclenchée au lieu de std::out_of_range [SWS_CORE_01728]. En cas d'erreur, celle-ci est mise à disposition sous la forme d'un état d'erreur dans l'objet Result renvoyé, de sorte que l'opération reste sûre face aux exceptions malgré une valeur de paramètre invalide [SWS_CORE_01728].

Interaction et délimitation

Dans le module core, il existe en complément pour ara::core::Bitset la surcharge sans paramètre reset(), qui efface tous les bits du conteneur en une seule fois et fournit directement une référence vers l'objet [SWS_CORE_01727]. De plus, les exigences associées [SWS_CORE_01136] et [SWS_CORE_01165] définissent une méthode du même nom pour ara::core::Optional, qui y supprime la valeur contenue.

concurrence

Comme reset modifie l'état interne du bitset, un appel simultané sur la même instance sans synchronisation externe ne devrait pas être sûr du point de vue des threads (interprétation : adoption de la sémantique usuelle des conteneurs C++). Question Q-e2e1c041eadedf0f (ouverte)

La fonction membre synchrone set() de la classe ara::core::Bitset affecte à tous les bits contenus dans l'objet la valeur true ([SWS_CORE_01725]). Elle correspond en matière de comportement au fonctionnement de std::bitset de la norme ISO C++ et est disponible via l'en-tête ara/core/bitset.h ([SWS_CORE_01725]). L'appel de méthode s'effectue sans paramètre et renvoie une référence lvalue vers le bitset modifié (Bitset<N>&) ([SWS_CORE_01725]), ce qui permet un chaînage direct d'autres appels sur la même instance.

L'opération est déclarée comme noexcept et possède la propriété exception safe ([SWS_CORE_01725]). Comme elle itère sur tous les bits ou définit l'état global, aucune erreur de plage ne survient, contrairement aux accès basés sur la position. La spécification ne formule aucune affirmation concernant la sécurité des threads ; Interprétation : l'état de l'objet étant directement muté, des accès parallèles à la même instance de Bitset sans sécurisation externe ne devraient pas être sûrs vis-à-vis de la concurrence ou des threads. Question Q-f8c1b5721f668193 (ouverte)

Dans l'interaction au sein du module core, la fonction complète la variante surchargée set(std::size_t, bool) ([SWS_CORE_01726]). Alors que la version sans paramètre affecte avec succès l'ensemble du champ à coup sûr, la version paramétrée modifie de manière ciblée un bit individuel, renvoie le type Result<Bitset<N>&> et signale via une IsoStdOutOfRangeViolation si un index de position non valide est transmis ([SWS_CORE_01726]).

La fonction membre set de la classe ara::core::Bitset modifie le bit à la position indiquée pos à la valeur val conformément à [SWS_CORE_01726]. La fonction est déclarée dans l'en-tête #include "ara/core/bitset.h" et opère de manière synchrone ainsi que sûre au regard des exceptions.

Par rapport au comportement standard de std::bitset, la fonction présente deux divergences essentielles ([SWS_CORE_01726]) :

• La fonction est déclarée comme noexcept et ne lève pas d'exceptions C++.
• Si pos ne correspond à aucune position de bit valide, IsoStdOutOfRangeViolation est déclenché au lieu de std::out_of_range.

La valeur renvoyée est un Result<Bitset<N>&> ([SWS_CORE_01726]). En cas de succès, le Result contient une référence vers l'objet bitset modifié. Si pos se situe en dehors de la plage valide, le Result achemine la violation d'erreur correspondante.

À la différence de la variante sans paramètre set() ([SWS_CORE_01725]), qui définit tous les bits et renvoie directement Bitset<N>&, cette surcharge basée sur la position requiert l'évaluation de l'objet Result pour le traitement des erreurs de plage ([SWS_CORE_01726]).

Utilisation

La fonction membre synchrone test de la classe ara::core::Bitset vérifie l'état du bit à la position transmise pos conformément à [SWS_CORE_01743]. La position de bit souhaitée pos de type std::size_t est transmise en tant que paramètre d'appel. La fonction renvoie de manière synchrone une valeur de type bool, où true indique que le bit est défini et false qu'il n'est pas défini. Pour l'intégration et l'utilisation de la fonction dans le module Core de la plateforme Adaptive, l'en-tête ara/core/bitset.h doit être inclus [SWS_CORE_01743].

Traitement des erreurs et déviations

Le comportement fonctionnel suit fondamentalement la sémantique de std::bitset, mais présente deux divergences majeures spécifiques au système [SWS_CORE_01743] :

• La signature est déclarée comme noexcept et garantit une sécurité totale vis-à-vis des exceptions (exception safe) [SWS_CORE_01743].
• Si la position de bit pos ne correspond à aucune position de bit valide au sein de l'objet, la violation IsoStdOutOfRangeViolation est déclenchée au lieu d'une exception de type std::out_of_range [SWS_CORE_01743]. Sa description s'inspire de celle de std::out_of_range [SWS_CORE_01743].

Concurrence et restrictions

Puisque la fonction est spécifiée comme const, elle ne modifie pas l'instance. De multiples accès concurrents en lecture à la même instance de bitset devraient donc pouvoir être exécutés sans conflit de données en fonctionnement normal (interprétation). Question Q-585dbdfefac63391 (ouverte) Si des modifications en écriture ont lieu simultanément sur la même instance, une synchronisation externe par l'appelant est probablement requise.

La fonction membre to_uint16t de la classe ara::core::Bitset convertit le contenu du bitset en une valeur entière de type std::uint16_t ([SWS_CORE_01737], [SWS_APT_00025]). Elle constitue une extension spécifique à AUTOSAR et n'est pas contenue dans la norme ISO C++ ISO-14882 ([SWS_CORE_01737]). L'appel synchrone est mis à disposition via l'en-tête ara/core/bitset.h ([SWS_CORE_01737]).

Pour la valeur de retour générée, le premier bit du bitset correspond au bit de poids le plus faible (least significant bit) et le dernier bit au bit de poids le plus fort (most significant bit) du nombre ([SWS_CORE_01737]). Étant donné que la méthode est spécifiée comme constexpr, elle peut également être évaluée au moment de la compilation sur des instances constantes ([SWS_CORE_01737]).

L'opération est spécifiée comme thread-safe ainsi que exception safe ([SWS_CORE_01737]). Si la valeur des bits ne peut pas être représentée dans la plage de valeurs de std::uint16_t, une IsoStdOverflowErrorViolation est présente ([SWS_CORE_01737]). Interprétation : en raison de la déclaration noexcept, cette violation ne devrait pas être signalée via des exceptions C++ régulières, mais conduire à un traitement via des mécanismes de violations spécifiques à la plateforme. Question Q-785057e36fb7e434 (ouverte)

Utilisation et sémantique

La méthode to_uint32t est une fonction membre synchrone et sans paramètre de la classe ara::core::Bitset, fournie via l'en-tête ara/core/bitset.h [SWS_CORE_01738]. Elle convertit les bits de l'instance de bitset en une valeur entière non signée de 32 bits du type std::uint32_t [SWS_CORE_01738]. La fonction n'est pas incluse dans ISO-14882, mais est définie comme un alias spécifique à AUTOSAR pour ara::core::Bitset::to_ulong, qui utilise explicitement le type de données std::uint32_t issu de [SWS_APT_00028] [SWS_CORE_01738]. Lors du mappage de la séquence de bits, le premier bit du bitset correspond au bit de poids faible (least significant bit) de la valeur de retour et le dernier bit au bit de poids fort (most significant bit) [SWS_CORE_01738].

Gestion des erreurs et conditions limites

En cas d'erreur, la spécification définit la violation IsoStdOverflowErrorViolation, qui survient lorsque la valeur entière correspondant aux bits définis ne peut pas être représentée dans la plage de valeurs du type de retour [SWS_CORE_01738].

Concurrence et contexte d'exécution

La fonction est déclarée avec constexpr et noexcept [SWS_CORE_01738]. En matière de sécurité d'exécution, elle est spécifiée comme étant sans risque de concurrence (thread-safe) ainsi que sûre face aux exceptions (exception safe) [SWS_CORE_01738].

Utilisation

La fonction membre to_uint64t de la classe ara::core::Bitset convertit de manière synchrone les bits contenus dans le bitset en une valeur entière du type std::uint64_t ([SWS_CORE_01739]). L'opération est une extension spécifique à AUTOSAR et n'est pas définie dans ISO-14882 ([SWS_CORE_01739]). Elle agit comme un alias pour la méthode ara::core::Bitset::to_ullong, tout en utilisant de manière obligatoire et explicite le type std::uint64_t conformément à [SWS_APT_00031] ([SWS_CORE_01739]). La déclaration est fournie via le fichier d'en-tête #include "ara/core/bitset.h" ([SWS_CORE_01739]).

Pour le mappage bit à bit de la valeur de retour, le premier bit du bitset correspond au bit de poids faible (least significant bit) de la valeur générée et le dernier bit est assigné au bit de poids fort (most significant bit) ([SWS_CORE_01739]). Grâce à la qualification en tant que constexpr, l'évaluation peut avoir lieu aussi bien au moment de l'exécution qu'à la compilation dans des expressions constantes ([SWS_CORE_01739]).

Gestion des erreurs et concurrence

En matière de sécurité d'exécution, la fonction est déclarée avec noexcept, classée comme sûre face aux exceptions (exception safe) et peut être appelée sans risque de concurrence (thread-safe) sans restriction ([SWS_CORE_01739]). Lorsque la valeur entière correspondant aux bits ne peut pas être représentée dans le type cible, le cas d'erreur IsoStdOverflowErrorViolation est rencontré ([SWS_CORE_01739]). L'interface satisfait à l'exigence de niveau supérieur [RS_AP_00130].

Utilisation

La fonction membre to_uint8t de la classe ara::core::Bitset convertit de manière synchrone le contenu stocké du bitset en une valeur entière non signée de 8 bits du type std::uint8_t conformément à [SWS_CORE_01736] et [SWS_APT_00022]. Il s'agit d'une extension de fonction spécifique à AUTOSAR qui n'existe pas dans la norme ISO-14882 [SWS_CORE_01736]. La fonction est fournie via l'en-tête ara/core/bitset.h, est sans paramètre et déclarée comme constexpr et noexcept [SWS_CORE_01736]. Le premier bit de la séquence de bits correspond au bit de poids le plus faible (LSB) et le dernier bit au bit de poids le plus fort (MSB) de la valeur retournée [SWS_CORE_01736].

Gestion des erreurs

Si la valeur entière correspondant aux bits dans le bitset ne peut pas être représentée dans le type cible std::uint8_t, la violation IsoStdOverflowErrorViolation se produit [SWS_CORE_01736]. Malgré la déclaration noexcept, la fonction est spécifiée comme exception safe en ce qui concerne la sécurité vis-à-vis des exceptions [SWS_CORE_01736].

Concurrence et interaction

En tant que fonction membre constante, to_uint8t est explicitement déclarée comme thread-safe [SWS_CORE_01736], de sorte que les accès en lecture parallèles de plusieurs threads à la même instance soient sûrs. La représentation du type cible s'oriente d'après la définition issue de [SWS_APT_00022].

La fonction membre to_ullong de la classe ara::core::Bitset convertit de manière synchrone la séquence de bits stockée en une valeur entière du type unsigned long long [SWS_CORE_01735]. Elle est définie dans l'en-tête #include "ara/core/bitset.h" et déclarée comme constexpr ainsi que noexcept par rapport à la norme ISO std::bitset [SWS_CORE_01735].

Concernant le traitement des erreurs et le comportement vis-à-vis des exceptions, les dispositions suivantes s'appliquent :

• Gestion du dépassement de capacité : si la valeur entière représentée par les bits définis ne peut pas être représentée dans le type de retour, la violation IsoStdOverflowErrorViolation est déclenchée au lieu d'une exception std::overflow_error [SWS_CORE_01735].
• Sécurité vis-à-vis des exceptions : la fonction est classée comme exception safe et, en raison de la spécification noexcept, ne lève aucune exception C++ [SWS_CORE_01735].

En interaction avec d'autres interfaces, AUTOSAR Adaptive fournit avec to_uint64t une alternative typée qui sert d'alias direct pour to_ullong, mais renvoie explicitement le type de largeur fixe std::uint64_t [SWS_CORE_01739]. Pour les deux fonctions, le premier bit du bitset correspond au bit de poids faible (LSB) et le dernier bit correspond au bit de poids fort (MSB) de la valeur numérique résultante [SWS_CORE_01739]. Comme to_ullong est une fonction membre constante et que son équivalent fonctionnel est spécifié comme thread-safe, un appel en lecture concurrent sur la même instance devrait également être thread-safe [SWS_CORE_01739]. Question Q-075766fabc193ce8 (ouverte)

La fonction membre ara::core::Bitset::to_ulong convertit de manière synchrone les bits définis d'une instance de bitset en une valeur entière de type unsigned long [SWS_CORE_01734]. La fonction requiert le fichier d'en-tête ara/core/bitset.h et appartient à la portée de la classe ara::core::Bitset [SWS_CORE_01734]. Grâce à la déclaration avec la signature constexpr unsigned long to_ulong() const noexcept;, l'évaluation peut avoir lieu aussi bien au moment de l'exécution qu'au moment de la compilation dans des expressions constantes [SWS_CORE_01734].

En ce qui concerne le comportement en cas d'erreur, la fonction se distingue nettement de la norme ISO std::bitset : si la valeur entière correspondant aux bits ne peut pas être représentée dans le type de retour unsigned long, une IsoStdOverflowErrorViolation est déclenchée au lieu d'une exception de type std::overflow_error [SWS_CORE_01734]. Nonobstant cette condition de violation, la fonction est déclarée comme noexcept et est formellement considérée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_01734].

En interaction avec d'autres fonctions de conversion, AUTOSAR Adaptive fournit avec to_uint32t un pendant direct qui sert d'alias pour to_ulong, mais renvoie de manière typée un std::uint32_t [SWS_CORE_01738]. Concernant la concurrence, la méthode devrait être thread-safe lors d'accès en lecture parallèles sur le même bitset (interprétation), car elle est définie comme const et l'exigence correspondante to_uint32t est expressément désignée comme thread-safe [SWS_CORE_01738]. Question Q-59f95b86801a697d (ouverte)