Developpez.com

Plus de 2 000 forums
et jusqu'à 5 000 nouveaux messages par jour

Boost.PropertyMap ou comment associer des objets clé à des objets valeur

Les Property Maps de Boost est un moyen d'utiliser dans des algorithmes des propriétés différentes. Par exemple, dans les algorithmes de graphes, les Property Maps permettent de donner à ceux-ci les capacités des arcs.

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Introduction

Boost.PropertyMap implémente quatre concepts à l'aide de plusieurs classes template. Chacune de ces classes implémente les concepts nécessaires à leur utilisation dans des algorithmes complexes, et ceci de manière interchangeable, qu'elles soient stockées au départ dans des std::map ou de simple tableaux.

I. Les concepts

Au nombre de 4, ces concepts proposent une interface aux classes qui les implémentent, selon leurs capacités.

I-A. Readable Property Map

Cette Property Map peut être lue à l'aide de la fonction get(). Outre cette fonction, plusieurs types sont indispensables, dépendant de PMap, le type de la Property Map.

Type Code correpondant Explication
Type de valeur boost::property_traits<PMap>::value_type Type de la propriété
Type de référence boost::property_traits<PMap>::reference Type qui peut se convertir en un type de valeur
Type de clé boost::property_traits<PMap>::key_type Type permettant d'effectuer une recherche d'une valeur. Peut valoir void si le type de clé est template
Catégorie boost::property_traits<PMap>::category Type de la catégorie, doit pouvoir se convertir en readable_property_map_tag

Une seule fonction doit être définie.

Nom Expression Type de retour Description
Get Property Value get(pmap, key) reference Retourne la valeur dans la Property Map pmap associée à la clé key

I-B. Writable Property Map

Cette Property Map est capable d'associer à une clé une valeur grâce à la fonction put(). Plusieurs types sont aussi indispensables.

Type Code correpondant Explication
Type de valeur boost::property_traits<PMap>::value_type Type de la propriété
Type de clé boost::property_traits<PMap>::key_type Type permettant d'effectuer une recherche d'une valeur. Peut valoir void si le type de clé est template
Catégorie boost::property_traits<PMap>::category Type de la catégorie, doit pouvoir se convertir en writable_property_map_tag

Une seule fonction doit être définie.

Nom Expression Type de retour Description
Put Property Value put(pmap, key, val) void Affecte dans la Property Map pmap la valeur val à la clé key

I-C. Read/Write Property Map

Ce concept hérite des 2 précédents, avec une petite différence pour le type de catégorie.

Type Code correpondant Explication
Catégorie boost::property_traits<PMap>::category Type de la catégorie, doit pouvoir se convertir en lvalue_property_map_tag

I-D. Lvalue Property Map

Une telle Property Map peut hériter de Readable Property Map ou de Read/Write Property Map selon qu'elle soit constante ou non - mutable -. On peut accéder à une référence indexée par une clé grâce à une interface particulière.

Type Code correpondant Explication
Type de référence boost::property_traits<PMap>::reference Type qui peut se convertir en un type de valeur
Catégorie boost::property_traits<PMap>::category Type de la catégorie, doit pouvoir se convertir en writable_property_map_tag

Une fonction d'accesseur particulier doit être défini.

Nom Expression Type de retour Description
Access Property Value pmap[key] value_type& pour mutable, const value_type& sinon Retourne une référence vers l'objet indexé par la clé key

II. Les classes template de Property Map

II-A. identity_property_map

Cette Property Map est une Readable Property Map qui retourne la clé donnée en entrée.

Code Description
boost::property_traits<identity_property_map>::value_type Ce type est void, les fonctions de la Property Map sont templatées
boost::property_traits<identity_property_map>::key_type Ce type est void, les fonctions de la Property Map sont templatées
boost::property_traits<identity_property_map>::category Vaut readable_op_bracket_tag

Quelques fonctions membres indispensables sont utilisables.

Membre Description
identity_property_map() Constructeur par défaut
identity_property_map(const identity_property_map& x) Constructeur par recopie
template <class T> T operator[](T x) const Retourne une copie de l'élément x
template <class T> T get(const identity_property_map& pmap, T x) Fonction non-membre retournant une copie de x

II-B. iterator_property_map<RandomAccessIterator, OffsetMap, T, R>

Cette classe implémente le concept de Lvalue Property Map. À partir d'un itérateur à accès aléatoire, on peut accéder à n'importe quel élément avec un entier - comme pour un itérateur sur des vecteurs standards, on peut l'avancer ou le reculer à l'aide des additions, ici, c'est la même chose -. Le deuxième élément indispensable est un outil pour convertir la clé en cet entier qu'on va utiliser. Les autres paramètres ont des valeurs par défaut décrites dans le tableau suivant.

Paramètre Description Valeur par défaut
Iterator Modèle d'itérateur à accès aléatoire  
OffsetMap Modèle de Readable Property Map et la valeur associée doit pouvoir être convertie en type de différence pour l'itérateur précédent  
T Type de valeur de l'itérateur std::iterator_traits<RandomAccessIterator>::value_type
R Type de référence de l'itérateur std::iterator_traits<RandomAccessIterator>::reference

Et voici les membres associés à cette Property Map :

Membre Description
property_traits<iterator_property_map>::value_type Vaut std::iterator_traits<Iterator>::value_type
iterator_property_map(Iterator i) Constructeur, OffsetMap est construit par défaut
iterator_property_map(Iterator i, OffsetMap m) Constructeur
reference operator[](difference_type v) Retourne une référence selon la différence donnée

II-C. associative_property_map<UniquePairAssociativeContainer>

Cet adaptateur permet de transformer des objets répondants aux critères des conteneurs associatifs à paires - une paire clé/valeur - et des conteneurs associatifs à clé unique, comme std::map pour les transformer en Lvalue Property Map.

Paramètre Description Valeur par défaut
UniquePairAssociativeContainer Type répondant aux critères des conteneurs associatifs à paires et à clé unique  

Et voici les membres associés à cette Property Map :

Membre Description
property_traits<associative_property_map>::value_type Vaut UniquePairAssociativeContainer::data_type
associative_property_map() Constructeur par défaut
associative_property_map(UniquePairAssociativeContainer& c Constructeur
data_type& operator[](const key_type& k) const Retourne une référence selon la différence donnée. Les types sont dérivés de UniquePairAssociativeContainer

II-D. const_associative_property_map<UniquePairAssociativeContainer>

Cet adaptateur diffère du précédent en ne proposant qu'un accesseur retournant un élément constant.

Membre Description
const data_type& operator[](const key_type& k) const Retourne une référence selon la différence donnée. Les types sont dérivés de UniquePairAssociativeContainer

II-E. vector_property_map<T, IndexMap = identity_property_map>

Cette classe particulière se trouve entre une Property Map associative et une Property Map itérative. À la différence de cette dernière, le nombre d'éléments stockés peut varier. En fait, les données stockées sous la forme d'un vecteur qui croît à la demande. C'est à nouveau une implémentation du modèle Lvalue Property Map.

Paramètre Description Valeur par défaut
T Le type de valeur  
IndexMap Implémente le modèle de Readable Property Map et doit être convertible en std::vector<T>::size_type identity_property_map

Et voici les membres associés à cette Property Map :

Membre Description
vector_property_map(const IndexMap& index = IndexMap()) Constructeur pouvant prendre une IndexMap en paramètre
vector_property_map(unsigned initial_size, const IndexMap& index = IndexMap()) Constructeur prenant en plus la taille initiale de la Property Map
vector_property_map(const vector_property_map&) Constructeur par recopie
vector_property_map& operator=(const vector_property_map&) Opérateur d'assignation
reference operator[](const key_type& v) const Opérateur d'accès
std::vector<T>::iterator storage_begin()
std::vector<T>::iterator storage_end()
std::vector<T>::const_iterator storage_begin()
std::vector<T>::const_iterator storage_end()
Récupération d'itérateurs sur la Property Map
void reserve(unsigned size) Permet de réserver une taille pour éviter les changements de taille coûteux

II-F. Transformer un pointeur en Property Map

Afin d'utiliser un pointeur T*, des fonctions put et get existent pour palier l'absence naturelle de ces fonctions pour les pointeurs, ainsi qu'une spécialisation de property_traits afin de répondre aux nécessités d'une Read/Write Property Map.

III. Conclusion

Chaque Property Map, sauf identity_property_map, peut être construite à l'aide d'un make_xxx où xxx est le type à construire. Ces classes sont utilisées couremment dans Boost.Graph que nous étudierons par la suite, mais vous pouvez les utiliser dès que vous voulez utiliser des propriétés associées à un type de données.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Références

Boost.org
Introduction à Boost
Installation de Boost sous Visual C++ 2005 (Aurélien Regat-Barrel)
Boost.Array : les tableaux de taille fixe (Alp Mestan)
Boost.Conversion : les conversions non numériques
Boost.FileSystem : le système de fichiers
Boost.Graph : l'implémentation des graphes
Boost.PropertyMap : les Property Maps
Boost.Random : les nombres aléatoires
Boost.SmartPtr : les pointeurs intelligents
Boost.StaticAssert : les assertions statiques
Boost.Threads : l'utilisation de threads
  

Copyright © 2006 Matthieu Brucher. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.