structure std::hash< ara::core::Monostate >

La spécialisation std::hash<ara::core::Monostate> fournit un objet fonction conforme au standard pour le calcul des valeurs de hachage applicables à ara::core::Monostate [SWS_CORE_01671]. Par le biais de l'opérateur d'appel operator(), la structure reçoit une référence constante vers un objet Monostate et renvoie la valeur de hachage associée sous forme de size_t [SWS_CORE_01671]. Interprétation : l'objet Monostate ne possédant aucun état interne, une valeur uniforme et déterministe devrait être obtenue pour chaque instance. Question (ouverte) Comme contrainte majeure, l'opération est spécifiée comme noexcept ainsi que sûre vis-à-vis des exceptions, et exclut totalement les erreurs d'exécution.

plus ›

Contexte

La spécialisation de patron std::hash<ara::core::Monostate> constitue le lien fonctionnel entre le type de base d'AUTOSAR Adaptive ara::core::Monostate et l'infrastructure standard de hachage [SWS_CORE_01671]. Au sein du module core, ara::core::Monostate sert à représenter un état vide, par exemple comme type alternatif dans des variantes. Pour pouvoir utiliser de tels types de manière transparente dans des conteneurs de hachage associatifs ou des algorithmes de hachage génériques, la spécification définit une spécialisation explicite de la classe foncteur standard std::hash [SWS_CORE_01671].

La structure est mise à disposition via le fichier d'en-tête ara/core/variant.h [SWS_CORE_01671]. En tant qu'objet fonction de hachage, la spécialisation interagit principalement avec des implémentations de conteneurs génériques telles que des tables de hachage ainsi qu'avec des instances de ara::core::Monostate. Grâce au respect des conventions d'interface de la bibliothèque standard C++, elle agit comme un adaptateur garantissant un accès uniforme aux valeurs de hachage, y compris pour les composants sans état [SWS_CORE_01671].

Cycle de vie

La structure std::hash<ara::core::Monostate> est conçue comme un objet fonction ordinaire [SWS_CORE_01671]. N'ayant besoin d'aucune donnée propre à l'instance pour calculer la valeur de hachage, elle ne possède aucun état mutable personnel. La création et la destruction d'instances de la spécialisation ne requièrent aucune mesure particulière et n'engendrent aucun surcoût de mémoire dynamique.

Concernant la concurrence et la propriété, l'objet fonction est totalement sans état. L'opérateur d'appel de fonction operator() est déclaré comme const [SWS_CORE_01671]. Cela signifie que la même instance peut être utilisée en toute sécurité et de façon concurrente par plusieurs contextes d'exécution ou threads en parallèle. Aucune revendication de propriété exclusive n'existe sur les objets Monostate transmis, puisque ceux-ci ne sont lus que par le biais d'une référence constante [SWS_CORE_01671].

Parcours d'utilisation

Le chemin d'utilisation typique commence par l'inclusion du fichier d'en-tête ara/core/variant.h [SWS_CORE_01671] dans l'unité de traduction concernée. Dès que le fichier d'en-tête est inclus, la spécialisation est automatiquement disponible dans l'espace de nommage std et est résolue au besoin par les structures de données basées sur le hachage.

L'exécution proprement dite s'effectue via l'opérateur d'appel de fonction surchargé operator(), qui reçoit une référence constante vers un objet ara::core::Monostate [SWS_CORE_01671] : size_t operator() (ara::core::Monostate const &v) const noexcept; [SWS_CORE_01671]. En guise de résultat, l'appel renvoie une valeur numérique de hachage de type size_t [SWS_CORE_01671]. Interprétation : comme ara::core::Monostate ne porte par définition aucun état variable, la fonction devrait calculer une valeur de hachage déterministe et identique pour toutes les instances transmises. Question Q-a9e7ab0092428d3c (ouverte) En pratique, cet appel se déroule le plus souvent de manière transparente dans le cadre d'opérations de recherche ou d'insertion de structures de données de niveau supérieur.

Scénarios d'erreur

La spécification définit pour la méthode operator() un comportement strict vis-à-vis des exceptions et de la robustesse : l'opérateur est déclaré avec le spécificateur noexcept et explicitement classifié comme sûr vis-à-vis des exceptions (exception safe) [SWS_CORE_01671]. Cela garantit qu'aucune exception C++ n'est levée sous aucun prétexte pendant l'opération de hachage.

Il n'existe aucun code d'erreur spécifique, aucune valeur de retour destinée au signalement d'erreurs ni aucune précondition au-delà d'une référence d'objet syntaxiquement valide [SWS_CORE_01671]. L'appel ne peut donc jamais échouer. La postcondition de l'appel est toujours la fourniture réussie d'une valeur de hachage entière de type size_t, de sorte que les appelants n'ont pas à implémenter de branches de repli ou de traitement d'erreur [SWS_CORE_01671].