structure ara::core::is_nothrow_swappable

La structure template ara::core::is_nothrow_swappable fournit dans le module core de l'AUTOSAR Adaptive Platform (Release R25-11) un outil pour le moment de la compilation qui vérifie, de manière analogue à std::is_nothrow_swappable conformément à C++17 [meta.unary.prop], si deux instances d'un type sont échangeables sans exception. Elle est principalement utilisée dans les algorithmes et structures de données génériques afin de sécuriser des échanges sans exception par SFINAE ou par des assertions statiques. L'évaluation étant entièrement effectuée de manière statique par le compilateur, aucune ressource d'exécution ni erreur dynamique n'apparaît. En tant que condition aux limites essentielle, la vérification sans erreur suppose que le type de données transmis soit entièrement défini au moment de l'instanciation.

plus ›

Contexte

La structure template ara::core::is_nothrow_swappable fournit dans le module core de l'AUTOSAR Adaptive Platform (Release R25-11) un outil de métafonction pour la vérification statique de types. Sa définition sémantique renvoie directement à std::is_nothrow_swappable selon la norme ISO-C++17 ISO/IEC 14882:2017 (section [meta.unary.prop]). En tant que trait, elle sert aux développeurs de composants génériques à vérifier, dès la compilation, si deux lvalues d'un type de données concret T peuvent être échangées entre elles sans lever d'exceptions.

Dans le contexte architectural, le trait interagit principalement avec des algorithmes génériques, des conteneurs et des fonctions utilitaires du module AUTOSAR-Core ainsi qu'avec des implémentations spécifiques à l'application. La vérification devrait être typiquement utilisée dans des fonctions de bibliothèque ou structures de données génériques du module pour sécuriser des opérations d'échange garanties sans exception via SFINAE, static_assert ou des spécifications conditionnelles noexcept. Question Q-2d97f825685fd7df (ouverte) Cette vérification permet de s'assurer que des opérations telles que l'échange de contenus de tampons ou d'états satisfont aux exigences de robustesse et de déterminisme dans l'écosystème Adaptive.

Cycle de vie

ara::core::is_nothrow_swappable étant une pure structure de métaprogrammation de templates, elle ne possède aucun cycle de vie classique au moment de l'exécution. Il n'existe aucune phase d'instanciation, aucune allocation dynamique de mémoire ni aucun processus de destruction dans l'application en cours d'exécution. L'évaluation des propriétés s'effectue entièrement de manière statique par le compilateur au cours du processus de compilation.

De ce caractère purement statique découle également l'absence d'états d'exécution ou de transitions d'état. Le trait n'est soumis à aucune restriction en matière de concurrence, car l'interrogation de caractéristiques de type est neutre vis-à-vis des threads et sans effet de bord. De manière analogue au modèle standard, ara::core::is_nothrow_swappable hérite probablement de std::integral_constant<bool, ...>, fournissant ainsi la constante de type value ainsi que des opérateurs de conversion correspondants, qui sont disponibles sous forme de constantes sans surcoût à l'exécution. Question Q-2d4f07696ff1d090 (ouverte)

Parcours d'utilisation

Le chemin d'utilisation typique de ara::core::is_nothrow_swappable se divise en la définition d'un type à vérifier, l'interrogation statique de l'aptitude à l'échange et le contrôle des branchements au moment de la compilation :

• Mise à disposition du type de données : un type cible T est déclaré et implémente idéalement sa propre fonction swap marquée comme noexcept, ou s'appuie sur des sous-structures échangeables élément par élément.
• Vérification statique : au sein d'un contexte générique, le développeur instancie ara::core::is_nothrow_swappable<T> et lit l'élément de données booléen statique value.
• Optimisation conditionnelle ou assertion : le résultat contrôle les assertions static_assert, les surcharges SFINAE ou les clauses noexcept(...) dans les opérations de permutation personnalisées.

Cet enchaînement permet de garantir que les algorithmes de permutation n'émettent une garantie sans exception vers l'extérieur que si le type sous-jacent T satisfait effectivement cette condition.

Scénarios d'erreur

Les erreurs classiques à l'exécution, les codes d'erreur ou les exceptions ne se produisent pas lors de l'utilisation de ara::core::is_nothrow_swappable, car la construction n'est pas exécutée au moment de l'exécution. Les situations d'erreur se manifestent au contraire exclusivement pendant la compilation.

Interprétation : les types T qui sont incomplets au moment de l'instanciation (appelés incomplete types) devraient conduire à des erreurs de compilation, car la validité et la sécurité vis-à-vis des exceptions de l'expression swap requièrent une définition de type complète. Question Q-e2785ad38b24b360 (ouverte) Un autre scénario d'erreur survient lorsque les développeurs supposent à tort qu'un type est permutable sans émettre d'exception, à la suite de quoi une assertion statique (static_assert) interrompt de manière ciblée le processus de compilation afin d'écarter des risques inattendus à l'exécution.