#ifndef _LIBDATASTR #define _LIBDATASTR #ifdef __cplusplus extern "C" { #endif #include /* Code retour des fonctions constituant l'API */ typedef long DST_Status; #define DSS_OK SMS_OK /* La fonction s'est correctement exécutée et a produit un résultat */ #define DSS_KO SMS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */ #define DSS_YES SMS_OK /* Résultat booléen positif */ #define DSS_NO SMS_KO /* Résultat booléen négatif */ #define DSS_ERRMEM SMS_ERRMEM /* Problème d'allocation mémoire */ #define DSS_ERRAPI SMS_ERRAPI /* Utilisation incorrecte des API */ #define DSS_ERRSHM SMS_ERRSHM /* Problème relatif aux segments de mémoire partagée */ #define DSS_ERRSEM SMS_ERRSEM /* Problème relatif à l'utilisation des sémaphores */ #define DSS_ERRSIG SMS_ERRSIG /* Opération sur sémaphore interrompue par un signal */ #define DSS_ERRDLL -6 /* Problème de chargement dynamique de librairie */ #define DS_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */ /* Indicateurs */ typedef int DST_Flags; #define DSD_UNDEF 0 /* Flags d'ouverture d'une data structure */ #define DSD_OPEN SMD_OPEN /* autorise l'ouverture d'une structure existante */ #define DSD_CREATE SMD_CREATE /* autorise la création de la structure */ #define DSD_NEW ~(DSD_OPEN|DSD_CREATE) /* crée une autre structure dans un heap existant */ /* Flags de debug sur l'ouverture de la librairie */ #define DSD_DEBUG_NONE 0 /* pour n'afficher aucun message généré par les diverses librairies */ #define DSD_DEBUG 1 /* pour afficher les messages générés par la librairie */ #define DSD_DEBUG_ALL 2 /* pour afficher les messages générés par toutes les librairies sous-jacentes */ /*------------------------------------------------------------------------------*/ /* Utilisations possibles des flags d'ouverture */ /*------------------------------------------------------------------------------*/ /* */ /* DSD_OPEN */ /* -> ouvrir une structure existante */ /* -> ne pas la créer si elle n'existe pas */ /* */ /* DSD_OPEN | DSD_CREATE */ /* -> ouvrir une structure si elle existe */ /* -> la créer si elle n'existe pas */ /* */ /* DSD_CREATE */ /* -> créer une structure */ /* -> ne pas l'ouvrir si elle existe déjà */ /* */ /* DSD_CREATE | DSD_NEW */ /* -> créer la structure si elle n'existe pas */ /* -> créer une autre structure dans le même heap si elle existe déjà */ /* */ /* DSD_NEW */ /* -> créer une autre structure dans le même heap si elle existe déjà */ /* -> ne pas la créer si elle n'existe pas */ /* */ /*------------------------------------------------------------------------------*/ /* Flags de verrouillage d'une data structure */ #define DSD_READ SMD_READ /* verrou partagé */ #define DSD_WRITE SMD_WRITE /* verrou exclusif */ /* Flags de fermeture d'une data structure */ #define DSD_CLOSE SMD_CLOSE /* pour fermer simplement la structure */ #define DSD_DESTROY SMD_DESTROY /* pour détruire la structure */ /* Masques pour récupérer des valeurs combinées */ #define DSD_MSK_OPEN(a) (DSD_OPEN & (a)) #define DSD_MSK_CREATE(a) (DSD_CREATE & (a)) #define DSD_MSK_NEW(a) (DSD_NEW & (a)) #define DSD_MSK_READ(a) (DSD_READ & (a)) #define DSD_MSK_WRITE(a) (DSD_WRITE & (a)) #define DSD_MSK_RW(a) ((DSD_READ | DSD_WRITE) & (a)) /* On utilise le pointeur 'User' de la racine de la struture pour y rattacher des données sur le heap sous-jacent. */ typedef struct { char * Heap_Name; char * Manager_FileName; int OpenSemID; /* Indique le nombre de processus ayant ouvert la struture */ int Heap_Owner; /* Indique si la structure est propriétaire du heap sous-jacent */ int Valid; /* Indique si la structure est valide ou non */ } DST_RootDesc; char DS_Error_Msg [512]; /* Définition des alias de l'API */ #ifndef DS_MODE #define DS_MODE 0 #endif #if DS_MODE == 2 /* Utilisation des API sans vérification des arguments et sans verrouillage de des data structures utilisées. Cette configuration correspond à une utilisation optimisée mais non sécurisée des API de la librairie. Puisque les verrouillages ne sont pas faits systématiquement par les fonctions, l'utilisateur veillera à verrouiller lui-même les data structures qu'il utilise. */ # define DS_Library_Open DS_Library_Open_I # define DS_Library_Close DS_Library_Close_I # define DS_Library_Stderr_Set DS_Library_Stderr_Set_I # define DS_DataStruct_Open DS_DataStruct_Open_I # define DS_DataStruct_Close DS_DataStruct_Close_I # define DS_DataStruct_Reorg DS_DataStruct_Reorg_I # define DS_DataStruct_Traverse DS_DataStruct_Traverse_I # define DS_DataStruct_Convert DS_DataStruct_Convert_I # define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_I # define DS_DataStruct_Print DS_DataStruct_Print_I # define DS_DataStruct_Check DS_DataStruct_Check_I # define DS_DataStruct_Dump DS_DataStruct_Dump_I # define DS_DataStruct_Lock DS_DataStruct_Lock_I # define DS_DataStruct_Unlock DS_DataStruct_Unlock_I # define DS_Node_Root_Get DS_Node_Root_Get_I # define DS_Node_First_Get DS_Node_First_Get_I # define DS_Node_Last_Get DS_Node_Last_Get_I # define DS_Node_Next_Get DS_Node_Next_Get_I # define DS_Node_Previous_Get DS_Node_Previous_Get_I # define DS_Node_Add DS_Node_Add_I # define DS_Node_Remove DS_Node_Remove_I # define DS_Node_Find DS_Node_Find_I # define DS_Value_Alloc DS_Value_Alloc_I # define DS_Value_Add DS_Value_Add_I # define DS_Value_Remove DS_Value_Remove_I # define DS_Value_Free DS_Value_Free_I # define DS_Alloc DS_Alloc_I # define DS_Free DS_Free_I #elif DS_MODE == 1 /* Utilisation des API sans vérification des arguments mais avec verrouillage systématique des data structures utilisées. */ # define DS_Library_Open DS_Library_Open_L # define DS_Library_Close DS_Library_Close_L # define DS_Library_Stderr_Set DS_Library_Stderr_Set_L # define DS_DataStruct_Open DS_DataStruct_Open_L # define DS_DataStruct_Close DS_DataStruct_Close_L # define DS_DataStruct_Reorg DS_DataStruct_Reorg_L # define DS_DataStruct_Traverse DS_DataStruct_Traverse_L # define DS_DataStruct_Convert DS_DataStruct_Convert_L # define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_L # define DS_DataStruct_Print DS_DataStruct_Print_L # define DS_DataStruct_Check DS_DataStruct_Check_L # define DS_DataStruct_Dump DS_DataStruct_Dump_L # define DS_DataStruct_Lock DS_DataStruct_Lock_L # define DS_DataStruct_Unlock DS_DataStruct_Unlock_L # define DS_Node_Root_Get DS_Node_Root_Get_L # define DS_Node_First_Get DS_Node_First_Get_L # define DS_Node_Last_Get DS_Node_Last_Get_L # define DS_Node_Next_Get DS_Node_Next_Get_L # define DS_Node_Previous_Get DS_Node_Previous_Get_L # define DS_Node_Add DS_Node_Add_L # define DS_Node_Remove DS_Node_Remove_L # define DS_Node_Find DS_Node_Find_L # define DS_Value_Alloc DS_Value_Alloc_L # define DS_Value_Add DS_Value_Add_L # define DS_Value_Remove DS_Value_Remove_L # define DS_Value_Free DS_Value_Free_L # define DS_Alloc DS_Alloc_L # define DS_Free DS_Free_L #else /* Utilisation des API avec vérification des arguments et avec verrouillage des data structures utilisées. */ # define DS_Library_Open DS_Library_Open_CL # define DS_Library_Close DS_Library_Close_CL # define DS_Library_Stderr_Set DS_Library_Stderr_Set_CL # define DS_DataStruct_Open DS_DataStruct_Open_CL # define DS_DataStruct_Close DS_DataStruct_Close_CL # define DS_DataStruct_Reorg DS_DataStruct_Reorg_CL # define DS_DataStruct_Traverse DS_DataStruct_Traverse_CL # define DS_DataStruct_Convert DS_DataStruct_Convert_CL # define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_CL # define DS_DataStruct_Print DS_DataStruct_Print_CL # define DS_DataStruct_Check DS_DataStruct_Check_CL # define DS_DataStruct_Dump DS_DataStruct_Dump_CL # define DS_DataStruct_Lock DS_DataStruct_Lock_CL # define DS_DataStruct_Unlock DS_DataStruct_Unlock_CL # define DS_Node_Root_Get DS_Node_Root_Get_CL # define DS_Node_First_Get DS_Node_First_Get_CL # define DS_Node_Last_Get DS_Node_Last_Get_CL # define DS_Node_Next_Get DS_Node_Next_Get_CL # define DS_Node_Previous_Get DS_Node_Previous_Get_CL # define DS_Node_Add DS_Node_Add_CL # define DS_Node_Remove DS_Node_Remove_CL # define DS_Node_Find DS_Node_Find_CL # define DS_Value_Alloc DS_Value_Alloc_CL # define DS_Value_Add DS_Value_Add_CL # define DS_Value_Remove DS_Value_Remove_CL # define DS_Value_Free DS_Value_Free_CL # define DS_Alloc DS_Alloc_CL # define DS_Free DS_Free_CL #endif /*------------------------------------------------------------------------------*/ /* Ouverture d'une instance de la librairie */ /*------------------------------------------------------------------------------*/ /* (I) Instance : numéro de l'instance de la librairie */ /* (I) Context : nom du contexte */ /* (I) Debug_Mode : mode d'affichage des messages d'erreur */ /*------------------------------------------------------------------------------*/ DST_Status DS_Library_Open_I ( int Instance, const char * Context, \ DST_Flags Debug_Mode ); DST_Status DS_Library_Open_L ( int Instance, const char * Context, \ DST_Flags Debug_Mode ); DST_Status DS_Library_Open_CL ( int Instance, const char * Context, \ DST_Flags Debug_Mode ); /*------------------------------------------------------------------------------*/ /* Fermeture de l'instance de la librairie */ /*------------------------------------------------------------------------------*/ DST_Status DS_Library_Close_I ( void ); DST_Status DS_Library_Close_L ( void ); DST_Status DS_Library_Close_CL ( void ); /*------------------------------------------------------------------------------*/ /* Définition de la sortie standard des messages d'erreur de la librairie */ /*------------------------------------------------------------------------------*/ /* (I) Out : flux de sortie des messages d'erreur */ /*------------------------------------------------------------------------------*/ DST_Status DS_Library_Stderr_Set_I ( FILE * Out ); DST_Status DS_Library_Stderr_Set_L ( FILE * Out ); DST_Status DS_Library_Stderr_Set_CL ( FILE * Out ); /*------------------------------------------------------------------------------*/ /* Création / ouverture d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) DS_Name : nom de la structure */ /* (O) Root : adresse du pointeur sur la racine de la structure */ /* (I) Type : type de la structure de données */ /* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ /* (I) Segment_Size : taille ds segments du heap sous-jacent */ /* (I) Open_Mode : mode d'ouverture de la structure */ /* (I) Own_Value : indique si la structure possède ses valeurs */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ NDT_DataStruct_Type Type, const char * Manager_FileName, \ size_t Segment_Size, DST_Flags Open_Mode, int Own_Value ); DST_Status DS_DataStruct_Open_L ( const char * DS_Name, NDT_Root ** Root,\ NDT_DataStruct_Type Type, const char * Manager_FileName, \ size_t Segment_Size, DST_Flags Open_Mode, int Own_Value ); DST_Status DS_DataStruct_Open_CL ( const char * DS_Name, NDT_Root ** Root,\ NDT_DataStruct_Type Type, const char * Manager_FileName, \ size_t Segment_Size, DST_Flags Open_Mode, int Own_Value ); /*------------------------------------------------------------------------------*/ /* Verrouillage d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure */ /* (I) Lock_Mode : type de verrou à poser sur la structure */ /* (O) Locked : verrou effectif (TRUE ou FALSE) */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Lock_I ( NDT_Root * Root, DST_Flags Lock_Mode, \ int * Locked ); DST_Status DS_DataStruct_Lock_L ( NDT_Root * Root, DST_Flags Lock_Mode, \ int * Locked ); DST_Status DS_DataStruct_Lock_CL ( NDT_Root * Root, DST_Flags Lock_Mode, \ int * Locked ); /*------------------------------------------------------------------------------*/ /* Déverrouillage d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Unlock_I ( NDT_Root * Root ); DST_Status DS_DataStruct_Unlock_L ( NDT_Root * Root ); DST_Status DS_DataStruct_Unlock_CL ( NDT_Root * Root ); /*------------------------------------------------------------------------------*/ /* Fermeture d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ); DST_Status DS_DataStruct_Close_L ( NDT_Root * Root, DST_Flags Close_Mode ); DST_Status DS_DataStruct_Close_CL ( NDT_Root * Root, DST_Flags Close_Mode ); /*------------------------------------------------------------------------------*/ /* Affiche les informations d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root: pointeur sur la racine de la structure de données */ /* (I) Out : flux de sortie de l'affichage */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out ); DST_Status DS_DataStruct_Info_Print_L ( NDT_Root * Root, FILE * Out ); DST_Status DS_DataStruct_Info_Print_CL ( NDT_Root * Root, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Réorganisation d'une structure de données : */ /* - ordonnancement d'une liste non ordonnée */ /* - réquilibrage d'un arbre non auto-équilibré */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Reorg_I ( NDT_Root * Root ); DST_Status DS_DataStruct_Reorg_L ( NDT_Root * Root ); DST_Status DS_DataStruct_Reorg_CL ( NDT_Root * Root ); /*------------------------------------------------------------------------------*/ /* Parcours de tous les noeuds d'une structure de données et exécution d'une */ /* commande sur chacun d'eux */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Command : Commande à exécuter sur chaque noeud traversé */ /* (I) Data : pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, \ void * Data ); DST_Status DS_DataStruct_Traverse_L ( NDT_Root * Root, NDT_Command Command, \ void * Data ); DST_Status DS_DataStruct_Traverse_CL ( NDT_Root * Root, NDT_Command Command, \ void * Data ); /*------------------------------------------------------------------------------*/ /* Conversion d'une structure de données d'un type en un autre */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Target_Type : type de structure cible */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Convert_I ( NDT_Root * Root, \ NDT_DataStruct_Type Target_Type ); DST_Status DS_DataStruct_Convert_L ( NDT_Root * Root, \ NDT_DataStruct_Type Target_Type ); DST_Status DS_DataStruct_Convert_CL ( NDT_Root * Root, \ NDT_DataStruct_Type Target_Type ); /*------------------------------------------------------------------------------*/ /* Affichage de la valeur de tous les noeuds d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Print_I ( NDT_Root * Root, FILE * Out ); DST_Status DS_DataStruct_Print_L ( NDT_Root * Root, FILE * Out ); DST_Status DS_DataStruct_Print_CL ( NDT_Root * Root, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Fonction de vérification / réparation d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure */ /* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ /* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ /* (I) Out : flux de sortie du rapport */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, \ int * Nb_Corrected, FILE * Out ); DST_Status DS_DataStruct_Check_L ( NDT_Root * Root, int * Nb_Detected, \ int * Nb_Corrected, FILE * Out ); DST_Status DS_DataStruct_Check_CL ( NDT_Root * Root, int * Nb_Detected, \ int * Nb_Corrected, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Affichage de la structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure */ /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out ); DST_Status DS_DataStruct_Dump_L ( NDT_Root * Root, FILE * Out ); DST_Status DS_DataStruct_Dump_CL ( NDT_Root * Root, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Récupération du premier noeud d'une structure */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine dont on cherche le premier noeud */ /* (O) Node : pointeur sur le noeud à récupérer */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_First_Get_I ( NDT_Root * Root, NDT_Node ** Node ); DST_Status DS_Node_First_Get_L ( NDT_Root * Root, NDT_Node ** Node ); DST_Status DS_Node_First_Get_CL ( NDT_Root * Root, NDT_Node ** Node ); /*------------------------------------------------------------------------------*/ /* Récupération du dernier noeud d'une structure */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine dont on cherche le dernier noeud */ /* (O) Node : pointeur sur le noeud à récupérer */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_Last_Get_I ( NDT_Root * Root, NDT_Node ** Node ); DST_Status DS_Node_Last_Get_L ( NDT_Root * Root, NDT_Node ** Node ); DST_Status DS_Node_Last_Get_CL ( NDT_Root * Root, NDT_Node ** Node ); /*------------------------------------------------------------------------------*/ /* Récupération du noeud suivant */ /*------------------------------------------------------------------------------*/ /* (I) Node : pointeur sur le noeud dont on cherche le suivant */ /* (O) Next_Node : pointeur sur le noeud suivant */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_Next_Get_I ( NDT_Node * Node, NDT_Node ** Next_Node ); DST_Status DS_Node_Next_Get_L ( NDT_Node * Node, NDT_Node ** Next_Node ); DST_Status DS_Node_Next_Get_CL ( NDT_Node * Node, NDT_Node ** Next_Node ); /*------------------------------------------------------------------------------*/ /* Récupération du noeud précédant */ /*------------------------------------------------------------------------------*/ /* (I) Node : pointeur sur le noeud dont on cherche le précédant */ /* (O) Prev_Node : pointeur sur le noeud précédant */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_Previous_Get_I ( NDT_Node * Node, NDT_Node ** Prev_Node ); DST_Status DS_Node_Previous_Get_L ( NDT_Node * Node, NDT_Node ** Prev_Node ); DST_Status DS_Node_Previous_Get_CL ( NDT_Node * Node, NDT_Node ** Prev_Node ); /*------------------------------------------------------------------------------*/ /* Ajout d'un noeud à une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Node : pointeur sur le noeud à ajouter */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_Add_I ( NDT_Root * Root, NDT_Node * Node ); DST_Status DS_Node_Add_L ( NDT_Root * Root, NDT_Node * Node ); DST_Status DS_Node_Add_CL ( NDT_Root * Root, NDT_Node * Node ); /*------------------------------------------------------------------------------*/ /* Suppression d'un noeud dans une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Node: pointeur sur le noeud à supprimer de la structure de données */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_Remove_I ( NDT_Node * Node ); DST_Status DS_Node_Remove_L ( NDT_Node * Node ); DST_Status DS_Node_Remove_CL ( NDT_Node * Node ); /*------------------------------------------------------------------------------*/ /* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de l'abre */ /* (O) Node : adresse du pointeur sur le noeud à récuperer */ /* (I) Value : pointeur sur la valeur à rechercher */ /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ DST_Status DS_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, \ void * Value, void * Data ); DST_Status DS_Node_Find_L ( NDT_Root * Root, NDT_Node ** Node, \ void * Value, void * Data ); DST_Status DS_Node_Find_CL ( NDT_Root * Root, NDT_Node ** Node, \ void * Value, void * Data ); /*------------------------------------------------------------------------------*/ /* Allocation d'une valeur d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (O) Value : adresse d'un pointeur sur la valeur à allouer */ /* (I) ... : arguments relatifs à l'allocation de la valeur */ /*------------------------------------------------------------------------------*/ DST_Status DS_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ); DST_Status DS_Value_Alloc_L ( NDT_Root * Root, void ** Value, ... ); DST_Status DS_Value_Alloc_CL ( NDT_Root * Root, void ** Value, ... ); /*------------------------------------------------------------------------------*/ /* Ajout d'une valeur à une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Value : pointeur sur la valeur à ajouter */ /*------------------------------------------------------------------------------*/ DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value ); DST_Status DS_Value_Add_L ( NDT_Root * Root, void * Value ); DST_Status DS_Value_Add_CL ( NDT_Root * Root, void * Value ); /*------------------------------------------------------------------------------*/ /* Suppression du premier noeud correspondant à une valeur donnée */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Reference_Value : pointeur sur la valeur de référence */ /* (I) Removed_Value : adresse d'un pointeur sur la valeur supprimée */ /*------------------------------------------------------------------------------*/ DST_Status DS_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, \ void ** Removed_Value); DST_Status DS_Value_Remove_L ( NDT_Root * Root, void * Reference_Value, \ void ** Removed_Value); DST_Status DS_Value_Remove_CL ( NDT_Root * Root, void * Reference_Value, \ void ** Removed_Value); /*------------------------------------------------------------------------------*/ /* Désallocation d'une valeur d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Value : pointeur sur la valeur à désallouer */ /*------------------------------------------------------------------------------*/ DST_Status DS_Value_Free_I ( NDT_Root * Root, void * Value ); DST_Status DS_Value_Free_L ( NDT_Root * Root, void * Value ); DST_Status DS_Value_Free_CL ( NDT_Root * Root, void * Value ); /*------------------------------------------------------------------------------*/ /* Allocation de mémoire pour une structure de données : */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Size : taille mémoire à allouer */ /* (O) Ptr : adresse du pointeur sur la zone de données allouée */ /*------------------------------------------------------------------------------*/ DST_Status DS_Alloc_I ( NDT_Root * Root, size_t Size, void ** Ptr ); DST_Status DS_Alloc_L ( NDT_Root * Root, size_t Size, void ** Ptr ); DST_Status DS_Alloc_CL ( NDT_Root * Root, size_t Size, void ** Ptr ); /*------------------------------------------------------------------------------*/ /* Désallocation d'une ressource pour une structure de données : */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Ptr : pointeur sur la zone à désallouer */ /*------------------------------------------------------------------------------*/ DST_Status DS_Free_I ( NDT_Root * Root, void * Ptr ); DST_Status DS_Free_L ( NDT_Root * Root, void * Ptr ); DST_Status DS_Free_CL ( NDT_Root * Root, void * Ptr ); #ifdef __cplusplus } #endif #endif