namespace std

Dans le module core, l'espace de nommage std met à disposition des spécialisations de modèles de std::hash, std::tuple_size et std::tuple_element pour les types de données de l'AUTOSAR Adaptive Platform. Cela permet l'utilisation directe de types tels que ara::core::String, ara::core::Optional, ara::core::Variant, ara::core::Vector et ara::core::Array dans des conteneurs standard et avec les mécanismes de tuples C++. La condition aux limites est que, pour les types imbriqués, les types de données contenus doivent également disposer de spécialisations valides à la compilation.

plus ›

Contexte

Dans le module core de l'AUTOSAR Adaptive Platform, l'espace de nommage std sert à l'intégration transparente des types de base spécifiques à la plateforme dans la bibliothèque standard C++. Au lieu d'introduire de nouveaux types, l'espace de nommage fournit des spécialisations de modèles ciblées de classes utilitaires standardisées. Les partenaires d'interaction comprennent trois composants essentiels : les types génériques de la bibliothèque standard C++ (en particulier les conteneurs associatifs non ordonnés et les utilitaires de tuples), les spécialisations de modèles au sein de std ainsi que les types de données ara::core::Array, ara::core::Monostate, ara::core::Optional, ara::core::String, ara::core::StringView, ara::core::Variant et ara::core::Vector définis dans le module core.

Diagramme de contexte : interaction entre les conteneurs standard, les spécialisations dans std et les types ara::core. Sources : déclarations du payload du module core

Les spécialisations de std::hash permettent d'utiliser directement des types de données du noyau adaptatif comme clés dans des conteneurs standard tels que std::unordered_map ou std::unordered_set. En parallèle, les spécialisations std::tuple_size et std::tuple_element pour ara::core::Array étendent la prise en charge des interfaces de métaprogrammation et des mécanismes de langage standardisés.

Parcours d'utilisation

Un chemin d'utilisation typique commence par l'emploi d'un type de données ara::core dans du code C++ générique. Par exemple, une application déclare une table de hachage avec des clés de type ara::core::String ou ara::core::Optional<T>. Lors de l'insertion, de la suppression ou de la recherche, le conteneur accède implicitement à std::hash<ara::core::String> ou std::hash<ara::core::Optional<T>> pour déterminer la valeur de hachage de la clé.

Les spécialisations couvrent différentes structures de données :

• Chaînes de caractères et vues : std::hash<ara::core::String> et std::hash<ara::core::StringView> calculent des valeurs de hachage sur la séquence de caractères contenue.
• Types composites : std::hash<ara::core::Optional<T>>, std::hash<ara::core::Variant<...>> et std::hash<ara::core::Vector<T, Allocator>> permettent le hachage de structures de types complexes. Interprétation : Les spécialisations pour ara::core::Optional et ara::core::Variant devraient s'aligner sur le comportement sémantique des modèles standardisés et générer des valeurs déterministes pour les états vides ou non occupés. Question Q-c432b06f0ba32c5e (ouverte)
• Types sans état : std::hash<ara::core::Monostate> fournit une fonction de hachage pour les états vides, tels qu'ils sont typiquement employés dans des variantes.
• Protocole de tuple : Pour les champs de données fixes, std::tuple_size<ara::core::Array<T, N>> fournit le nombre d'éléments au moment de la compilation, tandis que std::tuple_element<I, ara::core::Array<T, N>> détermine le type de données de la position I. Interprétation : Les spécialisations de std::tuple_size et std::tuple_element devraient ainsi permettre l'utilisation de ara::core::Array avec des liaisons structurées (Structured Bindings). Question Q-3abb70390e67dbce (ouverte)

Scénarios d'erreur

Puisque les éléments dans l'espace de nommage std sont exclusivement des spécialisations de modèles, les scénarios d'erreur surviennent principalement au moment de la compilation. Les configurations de problèmes typiques comprennent :

• Capacité de hachage manquante des types de base : Si std::hash est instancié pour un type imbriqué tel que ara::core::Optional<T> ou ara::core::Vector<T, Allocator>, une spécialisation valide de std::hash doit également être présente pour le type d'élément T. Si elle est absente, cela entraîne une erreur de compilation.
• Indexation non valide dans le protocole de tuple : L'accès à std::tuple_element<I, ara::core::Array<T, N>> avec un index I >= N viole la précondition du modèle et interrompt le processus de compilation.

Interprétation : Les scénarios d'erreur devraient pour l'essentiel se limiter à des erreurs au moment de la compilation en cas de spécialisations de types incomplètes ou de violations statiques de limites, car l'extrait de spécification ne définit aucun code d'erreur d'exécution ni d'interface d'exception. Question Q-8cda269c72bd701c (ouverte)