#ifndef _LIBNODE #define _LIBNODE #ifdef __cplusplus extern "C" { #endif #include #include #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif /* Différence de profondeur entre la branche la plus courte et la plus longue d'un arbre. Le dépassement de ce seuil provoque le rééquilibrage de l'arbre */ #define DEF_MAX_DIF 100 /* Types de structure */ typedef int NDT_DataStruct_Type; #define NDD_DS_LIST 0001 /* liste chaînée */ #define NDD_DS_TREE 0002 /* arbre binaire */ #define NDD_DS_MSK (NDD_DS_LIST | NDD_DS_TREE) #define ND_IS_LIST(r) ((r)->Type & NDD_DS_LIST) #define ND_IS_TREE(r) ((r)->Type & NDD_DS_TREE) #define NDD_MN_FIFO 0010 /* principe de la file d'attente (First In First Out) */ #define NDD_MN_LILO NDD_MN_FIFO #define NDD_MN_FILO 0020 /* principe de la pile (First In Last Out) */ #define NDD_MN_LIFO NDD_MN_FILO #define NDD_MN_ORDERED 0040 /* liste triée */ #define NDD_MN_AUTO_EQU 0100 /* arbre auto-équilibré */ #define NDD_MN_MSK (NDD_MN_FIFO | NDD_MN_FILO | NDD_MN_ORDERED | NDD_MN_AUTO_EQU) #define ND_IS_FIFO(r) ((r)->Type & NDD_MN_FIFO) #define ND_IS_FILO(r) ((r)->Type & NDD_MN_FILO) #define ND_IS_ORDERED(r) ((r)->Type & NDD_MN_ORDERED) #define ND_IS_AUTO_EQU(r) ((r)->Type & NDD_MN_AUTO_EQU) /* Commandes du manager */ typedef int NDT_Command; #define NDD_CMD_MAKE_VALUE 1 #define NDD_CMD_COMP_VALUE 2 #define NDD_CMD_SUM_VALUES 3 #define NDD_CMD_PRINT_VALUE 4 #define NDD_CMD_DELETE_VALUE 5 #define NDD_CMD_PRINT_INFO 6 /* Types de réponse du manager ou code retour des diverses fonctions */ typedef int NDT_Status; #define ND_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */ #define NDS_OK 1 #define NDS_KO 0 #define NDS_YES 1 #define NDS_NO 0 #define NDS_EQUAL 1 #define NDS_GREATER 2 #define NDS_LOWER 3 #define NDS_ERRMEM -1 /* Problème d'allocation mémoire */ #define NDS_ERRAPI -2 /* Utilisation incorrecte des API */ /* Pointeur de fonction sur le manager */ typedef NDT_Status NDT_Manager (va_list); /* Pointeur de fonction sur l'allocateur */ typedef NDT_Status NDT_Allocator (size_t, void **, void *); /* Pointeur de fonction sur le désallocateur */ typedef NDT_Status NDT_Desallocator (void *, void *); /* Structure racine */ typedef struct NDT_Root { NDT_DataStruct_Type Type; /* Type de la structure (liste, arbre ... ) */ long Node_Number; /* Nombre de noeuds dans la structure */ long Min_Depth; /* Profondeur minimale de l'arbre */ long Max_Depth; /* Profondeur maximale de l'arbre */ long Max_Dif; /* Différence maximale autorisée entre la branche la plus courte et la plus longue */ long Nb_Equ; /* Nombre de réquilibrages réalisés sur l'arbre */ char Manager [50]; /* Nom de la fonction manager */ char Allocator [50]; /* Nom de la fonction d'allocation */ char Desallocator [50]; /* Nom de la fonction de désallocation */ struct NDT_Node * Head; /* Noeud de tête */ struct NDT_Node * Queue; /* Noeud de queue */ struct NDT_Node * Save; /* Pointeur de sauvegarde (utile pour la fonction de restauration) */ void * User; /* Pointeur utilisable librement par l'utilisateur */ short int Own_Value; /* Indique si la structure est propriétaire de ses valeurs */ } NDT_Root; /* Structure de noeud */ typedef struct NDT_Node { struct NDT_Root * Root; struct NDT_Node * Parent; struct NDT_Node * Left; struct NDT_Node * Right; void * Value; } NDT_Node; char ND_Error_Msg [512]; /* Définition des alias de l'API */ #ifndef ND_MODE #define ND_MODE 0 #endif #if ND_MODE == 1 /* API sans vérification des arguments */ #define ND_Library_Open ND_Library_Open_I #define ND_Library_Close ND_Library_Close_I #define ND_Library_Stderr_Set ND_Library_Stderr_Set_I #define ND_DataStruct_Open ND_DataStruct_Open_I #define ND_DataStruct_Close ND_DataStruct_Close_I #define ND_DataStruct_Reorg ND_DataStruct_Reorg_I #define ND_DataStruct_Traverse ND_DataStruct_Traverse_I #define ND_DataStruct_Convert ND_DataStruct_Convert_I #define ND_DataStruct_Info_Print ND_DataStruct_Info_Print_I #define ND_DataStruct_Print ND_DataStruct_Print_I #define ND_DataStruct_Check ND_DataStruct_Check_I #define ND_DataStruct_Dump ND_DataStruct_Dump_I #define ND_Node_Root_Get ND_Node_Root_Get_I #define ND_Node_First_Get ND_Node_First_Get_I #define ND_Node_Last_Get ND_Node_Last_Get_I #define ND_Node_Next_Get ND_Node_Next_Get_I #define ND_Node_Previous_Get ND_Node_Previous_Get_I #define ND_Node_Add ND_Node_Add_I #define ND_Node_Remove ND_Node_Remove_I #define ND_Node_Find ND_Node_Find_I #define ND_Value_Alloc ND_Value_Alloc_I #define ND_Value_Add ND_Value_Add_I #define ND_Value_Remove ND_Value_Remove_I #define ND_Value_Free ND_Value_Free_I #define ND_Manager_Exec ND_Manager_Exec_I #define ND_Allocator_Exec ND_Allocator_Exec_I #define ND_Desallocator_Exec ND_Desallocator_Exec_I #else /* API avec vérification des arguments */ #define ND_Library_Open ND_Library_Open_C #define ND_Library_Close ND_Library_Close_C #define ND_Library_Stderr_Set ND_Library_Stderr_Set_C #define ND_DataStruct_Open ND_DataStruct_Open_C #define ND_DataStruct_Close ND_DataStruct_Close_C #define ND_DataStruct_Reorg ND_DataStruct_Reorg_C #define ND_DataStruct_Traverse ND_DataStruct_Traverse_C #define ND_DataStruct_Convert ND_DataStruct_Convert_C #define ND_DataStruct_Info_Print ND_DataStruct_Info_Print_C #define ND_DataStruct_Print ND_DataStruct_Print_C #define ND_DataStruct_Check ND_DataStruct_Check_C #define ND_DataStruct_Dump ND_DataStruct_Dump_C #define ND_Node_Root_Get ND_Node_Root_Get_C #define ND_Node_First_Get ND_Node_First_Get_C #define ND_Node_Last_Get ND_Node_Last_Get_C #define ND_Node_Next_Get ND_Node_Next_Get_C #define ND_Node_Previous_Get ND_Node_Previous_Get_C #define ND_Node_Add ND_Node_Add_C #define ND_Node_Remove ND_Node_Remove_C #define ND_Node_Find ND_Node_Find_C #define ND_Value_Alloc ND_Value_Alloc_C #define ND_Value_Add ND_Value_Add_C #define ND_Value_Remove ND_Value_Remove_C #define ND_Value_Free ND_Value_Free_C #define ND_Manager_Exec ND_Manager_Exec_C #define ND_Allocator_Exec ND_Allocator_Exec_C #define ND_Desallocator_Exec ND_Desallocator_Exec_C #endif /*------------------------------------------------------------------------------*/ /* Initialisation du contexte de la librairie */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Library_Open_I ( int Debug_Mode ); NDT_Status ND_Library_Open_C ( int Debug_Mode ); /*------------------------------------------------------------------------------*/ /* Fermeture du contexte de la librairie */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Library_Close_I ( void ); NDT_Status ND_Library_Close_C ( void ); /*------------------------------------------------------------------------------*/ /* Définition de la sortie standard des messages d'erreur de la librairie */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Library_Stderr_Set_I ( FILE * Out ); NDT_Status ND_Library_Stderr_Set_C ( FILE * Out ); /*------------------------------------------------------------------------------*/ /* Création d'une nouvelle structure de données */ /*------------------------------------------------------------------------------*/ /* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure */ /* (I) Type: type de la structure.de données (liste ou arbre binaire) */ /* (I) Allocator: pointeur vers la fonction d'allocation */ /* (I) Desallocator: pointeur vers la fonction de désallocation */ /* (I) Data : pointeur de données utiles à l'allocateur */ /* (I) Own_Value : indique si la structure est propriétaire de ses valeurs */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Open_I ( NDT_Root ** Root, NDT_DataStruct_Type Type, \ const char * Allocator, \ const char * Desallocator, \ void * Data, int Own_Value ); NDT_Status ND_DataStruct_Open_C ( NDT_Root ** Root, NDT_DataStruct_Type Type, \ const char * Allocator, \ const char * Desallocator, \ void * Data, int Own_Value ); /*------------------------------------------------------------------------------*/ /* Destruction d'une structure de données */ /*------------------------------------------------------------------------------*/ /* (O) Root: pointeur sur la racine de la structure de données */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Close_I ( NDT_Root * Root ); NDT_Status ND_DataStruct_Close_C ( NDT_Root * Root ); /*------------------------------------------------------------------------------*/ /* 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Reorg_I ( NDT_Root * Root ); NDT_Status ND_DataStruct_Reorg_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, \ void * Data ); NDT_Status ND_DataStruct_Traverse_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Convert_I ( NDT_Root * Root, \ NDT_DataStruct_Type Target_Type ); NDT_Status ND_DataStruct_Convert_C ( NDT_Root * Root, \ NDT_DataStruct_Type Target_Type ); /*------------------------------------------------------------------------------*/ /* Affichage d'informations sur une structure de données */ /*------------------------------------------------------------------------------*/ /* (I) Root: pointeur sur la racine de la structure de données */ /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out ); NDT_Status ND_DataStruct_Info_Print_C ( NDT_Root * Root, FILE * Out ); /*------------------------------------------------------------------------------*/ /* 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Print_I ( NDT_Root * Root, FILE * Out ); NDT_Status ND_DataStruct_Print_C ( NDT_Root * Root, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Function de réparation d'une structure : */ /* - vérifie que tous les noeuds sont correctement liés les uns aux autres */ /* - corrige les informations statistiques de la racine */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure */ /* (O) Nb_Detected : pointeur sur le nombre d'erreurs */ /* (O) Nb_Corrected : pointeur sur le nombre d'erreurs */ /* (I) Out : flux de sortie du rapport */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, \ int * Nb_Corrected, FILE * Out ); NDT_Status ND_DataStruct_Check_C ( NDT_Root * Root, int * Nb_Detected, \ int * Nb_Corrected, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Affiche la structure de données et ses informations statistiques */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure */ /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out ); NDT_Status ND_DataStruct_Dump_C ( NDT_Root * Root, FILE * Out ); /*------------------------------------------------------------------------------*/ /* Récupération de la racine d'une structure */ /*------------------------------------------------------------------------------*/ /* (O) Root: Adresse du pointeur sur la racine à récupérer */ /* (I) Node: pointeur sur le noeud dont on cherche la racine */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Root_Get_I ( NDT_Root ** Root, NDT_Node * Node ); NDT_Status ND_Node_Root_Get_C ( NDT_Root ** Root, NDT_Node * Node ); /*------------------------------------------------------------------------------*/ /* 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_First_Get_I ( NDT_Root * Root, NDT_Node ** Node ); NDT_Status ND_Node_First_Get_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Last_Get_I ( NDT_Root * Root, NDT_Node ** Node ); NDT_Status ND_Node_Last_Get_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Next_Get_I ( NDT_Node * Node, NDT_Node ** Next_Node ); NDT_Status ND_Node_Next_Get_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Previous_Get_I ( NDT_Node * Node, NDT_Node **Prev_Node ); NDT_Status ND_Node_Previous_Get_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Add_I ( NDT_Root * Root, NDT_Node * Node ); NDT_Status ND_Node_Add_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Remove_I ( NDT_Node * Node); NDT_Status ND_Node_Remove_C ( NDT_Node * Node); /*------------------------------------------------------------------------------*/ /* Recherche un noeud à partir d'une valeur */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de l'abre */ /* (O) Node : pointeur sur le noeud à récuperer */ /* (I) Value : pointeur sur la valeur à rechercher */ /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data ); NDT_Status ND_Node_Find_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ); NDT_Status ND_Value_Alloc_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Value_Add_I ( NDT_Root * Root, void * Value ); NDT_Status ND_Value_Add_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, void ** Removed_Value ); NDT_Status ND_Value_Remove_C ( 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 */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Value_Free_I ( NDT_Root * Root, void * Value ); NDT_Status ND_Value_Free_C ( NDT_Root * Root, void * Value ); /*------------------------------------------------------------------------------*/ /* Exécution d'une fonction Manager dont le nom est passé en paramètre */ /*------------------------------------------------------------------------------*/ /* (I) Function : nom de la fonction manager à exécuter */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Manager_Exec_I ( const char * Function, ... ); NDT_Status ND_Manager_Exec_C ( const char * Function, ... ); /*------------------------------------------------------------------------------*/ /* Exécution d'une fonction d'allocation dont le nom est passé en paramètre */ /*------------------------------------------------------------------------------*/ /* (I) Function : nom de la fonction à exécuter */ /* (O) Ptr : adresse d'un pointeur sur la zone à allouer */ /* (I) Size : taille de la zone à allouer */ /* (I) Data : pointeur de données utiles à l'allocateur */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Allocator_Exec_I ( const char * Function, void ** Ptr, \ size_t Size, void * Data ); NDT_Status ND_Allocator_Exec_C ( const char * Function, void ** Ptr, \ size_t Size, void * Data ); /*------------------------------------------------------------------------------*/ /* Exécution d'une fonction de désallocation le dont nom est passé en paramètre */ /*------------------------------------------------------------------------------*/ /* (I) Function : nom de la fonction à exécuter */ /* (I) Ptr : adresse de la zone à désallouer */ /* (I) Data : pointeur de données utiles au désallocateur */ /*------------------------------------------------------------------------------*/ NDT_Status ND_Desallocator_Exec_I ( const char * Function, void * Ptr, \ void * Data ); NDT_Status ND_Desallocator_Exec_C ( const char * Function, void * Ptr, \ void * Data ); #ifdef __cplusplus } #endif #endif