32 int* allouer_element(
int val ){
33 int* result = (
int*) xmalloc(
sizeof(
int) );
38 void supprimer_element(
int* element ){
55 next_iterators( &it1, &it2 )
58 if( ens1->comparer_element ){
63 if( cmp > 0 )
return 1;
64 if( cmp < 0 )
return -1;
75 int (*comparer_element)(
const intptr_t elem1,
const intptr_t elem2 ),
76 intptr_t (*copier_element)(
const intptr_t elem ),
77 void (*supprimer_element)(intptr_t elem )
81 comparer_element, copier_element, supprimer_element
83 result->comparer_element = comparer_element;
84 result->copier_element = copier_element;
85 result->supprimer_element = supprimer_element;
89 void liberer_ensemble(
Ensemble * ens ){
96 void ajouter_element(
Ensemble * ensemble,
const intptr_t element ){
97 add_table( ensemble->table, element, (intptr_t) NULL );
101 void action_ajouter_element(
const intptr_t element,
void* ens ){
102 ajouter_element( (
Ensemble*) ens, element );
106 pour_tout_element( ens2, action_ajouter_element, ens1 );
109 void transferer_elements_et_libere(
112 ajouter_elements( destination, source );
113 liberer_ensemble( source );
116 void transferer_elements(
119 ajouter_elements( destination, source );
120 vider_ensemble( source );
123 void retirer_element(
Ensemble * ensemble,
const intptr_t element ){
127 void action_retirer_elements(
const intptr_t element,
void* ens ){
128 retirer_element( (
Ensemble*) ens, element );
132 pour_tout_element( ens2, action_retirer_elements, ens1 );
135 void vider_ensemble(
Ensemble * ensemble ){
139 int est_dans_l_ensemble(
const Ensemble * ensemble, intptr_t element ){
141 return ! avl_t_is_null( &it );
144 void action_taille_ensemble(
const intptr_t element,
void* taille ){
148 unsigned int taille_ensemble(
const Ensemble* ensemble ){
150 pour_tout_element( ensemble, action_taille_ensemble, &taille );
155 void (*print_element)(
const intptr_t cle );
158 void action_print_ensemble(
const intptr_t element,
void* data ){
160 if( info->print_element ){
161 info->print_element( element );
163 printf(
"%ld", element );
170 void (*print_element)(
const intptr_t cle )
173 data.print_element = print_element;
176 pour_tout_element( ens, action_print_ensemble, &data );
182 void (* action )(
const intptr_t element,
void* data );
186 void action_pour_tout_element_ensemble(
const intptr_t cle, intptr_t valeur,
void* data ){
188 info->action( cle, info->data );
191 void pour_tout_element(
193 void (* action )(
const intptr_t element,
void* data ),
197 data1.action = action;
200 ensemble->table, action_pour_tout_element_ensemble, &data1
205 void* tmp = ens1->table;
206 ens1->table = ens2->table;
210 swap_ensemble( ens1, ens2 );
211 liberer_ensemble( ens2 );
216 ensemble->comparer_element, ensemble->copier_element,
217 ensemble->supprimer_element
219 ajouter_elements( res, ensemble );
224 Ensemble * res = copier_ensemble( ens1 );
225 ajouter_elements( res, ens2 );
229 Ensemble * creer_difference_ensemble(
232 Ensemble * res = copier_ensemble( ens1 );
233 retirer_elements( res, ens2 );
237 Ensemble * creer_intersection_ensemble(
241 tmp = creer_difference_ensemble( ens1, ens2 );
242 res = creer_difference_ensemble( ens1, tmp );
243 liberer_ensemble( tmp );
248 const Ensemble* ensemble,
const intptr_t element
void vider_table(Table *table)
Supprime toutes les clés de la table.
Table_iterateur premier_iterateur_table(const Table *table)
Renvoie un itérateur positionné sur la première association de la table.
intptr_t get_cle(Table_iterateur it)
Renvoie la clé de l'association pointée par l'itérateur passé en paramètre.
void pour_toute_cle_valeur_table(const Table *table, void(*action)(const intptr_t cle, intptr_t valeur, void *data), void *data)
La fonction passe en revue toutes les associaitons (clé, valeur) de la table, et apelle la fonction p...
void liberer_table(Table *table)
Cette fonction détruit une table. La mémoire qui a été allouée par la table pour stocker les clés son...
intptr_t delete_table(Table *table, const intptr_t cle)
Supprime une clé de la table. La mémoire de la clé est libérée et la valeur associée à la clé est per...
Table_iterateur iterateur_suivant_table(Table_iterateur iterator)
Renvoie l'itérateur suivant.
Table_iterateur iterateur_precedent_table(Table_iterateur iterator)
Renvoie l'itérateur précédent.
int iterateur_est_vide(Table_iterateur iterator)
Renvoie 1 si l'itérateur passé en paramètre est vide. Renvoie 0 sinon.
Table_iterateur trouver_table(const Table *table, const intptr_t cle)
Renvoie un itérateur positionné sur l'association dont la clé est identique (pour la fonction de comp...
Table * creer_table(int(*comparer_cle)(const intptr_t cle1, const intptr_t cle2), intptr_t(*copier_cle)(const intptr_t cle), void(*supprimer_cle)(intptr_t cle))
Renvoie une nouvelle table.
void add_table(Table *table, const intptr_t cle, const intptr_t valeur)
La fonction add_table() ajoute une association entre une clé et une valeur. Pour cela, add_table(), crée une copie de la clé passée en paramètre, l'enregistre dans la table et l'associe à la valeur passée en paramètre. La mémoire de la copie de la clé est gérée par la table. La mémoire de la clé passée en paramètre reste à la charge de l'utilisateur.