From 0ba642fd2a9a888e97e38af0e96a5aa0c24bff02 Mon Sep 17 00:00:00 2001 From: agibert Date: Mon, 26 Nov 2001 10:17:44 +0000 Subject: [PATCH] Merge win32 branche (1.1.2.30) with main trunc ! --- include/node.h | 895 ++++++++++++++++++++++++++++++++++++------------- 1 file changed, 660 insertions(+), 235 deletions(-) diff --git a/include/node.h b/include/node.h index 3024022..7641105 100644 --- a/include/node.h +++ b/include/node.h @@ -1,3 +1,14 @@ +/*---------------------------------------------------------------------------------*/ +/* $RCSfile: node.h,v $ */ +/*---------------------------------------------------------------------------------*/ +/* $Revision: 1.2 $ */ +/* $Name: $ */ +/* $Date: 2001/11/26 10:17:44 $ */ +/* $Author: agibert $ */ +/*---------------------------------------------------------------------------------*/ + + + #ifndef _LIBNODE #define _LIBNODE @@ -5,16 +16,31 @@ extern "C" { #endif +#include +#include +#include +#include #include -#include -#ifndef TRUE -#define TRUE 1 +#ifdef _LIBVER_SUPPORT +# include #endif -#ifndef FALSE -#define FALSE 0 -#endif + + + + + + +#define NDD_TRUE 1 + +#define NDD_FALSE 0 + +#define NDD_MIN(A,B) ((A > B) ? B : A) + +#define NDD_MAX(A,B) ((A < B) ? B : A) + + /* Différence de profondeur entre la branche la plus courte et @@ -26,38 +52,108 @@ extern "C" { /* Types de structure */ -typedef int NDT_DataStruct_Type; +typedef short NDT_Root_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) +typedef int NDT_Index_Type; -#define ND_IS_LIST(r) ((r)->Type & NDD_DS_LIST) -#define ND_IS_TREE(r) ((r)->Type & NDD_DS_TREE) +#define NDD_INDEX_MSK 0xffff +#define NDD_INDEX_RMSK 0x0000 + +#define NDD_INDEX_STATUS_UNKNOWN 0x0000 +#define NDD_INDEX_STATUS_OPENED 0x0001 +#define NDD_INDEX_STATUS_CLOSED 0x0002 +#define NDD_INDEX_STATUS_MSK (NDD_INDEX_STATUS_UNKNOWN | NDD_INDEX_STATUS_OPENED | NDD_INDEX_STATUS_CLOSED) +#define NDD_INDEX_STATUS_RMSK (NDD_INDEX_MSK ^ NDD_INDEX_STATUS_MSK) + +#define ND_INDEX_STATUS_VALUE_UNKNOWN_IS( v) ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_UNKNOWN) +#define ND_INDEX_STATUS_VALUE_OPENED_IS( v) ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_OPENED) +#define ND_INDEX_STATUS_VALUE_CLOSED_IS( v) ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_CLOSED) +#define ND_INDEX_STATUS_UNKNOWN_IS( r, i) ND_INDEX_STATUS_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_STATUS_OPENED_IS( r, i) ND_INDEX_STATUS_VALUE_OPENED_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_STATUS_CLOSED_IS( r, i) ND_INDEX_STATUS_VALUE_CLOSED_IS( (r)->Index_Tab[(i)].Type) + +#define ND_INDEX_STATUS_VALUE_ASCII_GET( v) ( ND_INDEX_STATUS_VALUE_UNKNOWN_IS( (v)) ? "UNKNOWN" : ( ND_INDEX_STATUS_VALUE_OPENED_IS( (v)) ? "OPENED" : ( ND_INDEX_STATUS_VALUE_CLOSED_IS( (v)) ? "CLOSED" : "???"))) +#define ND_INDEX_STATUS_ASCII_GET( r, i) ND_INDEX_STATUS_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type) + + + +#define NDD_INDEX_TYPE_UNKNOWN 0x0000 +#define NDD_INDEX_TYPE_LIST 0x0010 +#define NDD_INDEX_TYPE_TREE 0x0020 +#define NDD_INDEX_TYPE_MSK (NDD_INDEX_TYPE_UNKNOWN | NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE) +#define NDD_INDEX_TYPE_RMSK (NDD_INDEX_MSK ^ NDD_INDEX_TYPE_MSK) + +#define ND_INDEX_TYPE_VALUE_UNKNOWN_IS( v) ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_UNKNOWN) +#define ND_INDEX_TYPE_VALUE_LIST_IS( v) ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_LIST) +#define ND_INDEX_TYPE_VALUE_TREE_IS( v) ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_TREE) + +#define ND_INDEX_TYPE_UNKNOWN_IS( r, i) ND_INDEX_TYPE_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_TYPE_LIST_IS( r, i) ND_INDEX_TYPE_VALUE_LIST_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_TYPE_TREE_IS( r, i) ND_INDEX_TYPE_VALUE_TREE_IS( (r)->Index_Tab[(i)].Type) + +#define ND_INDEX_TYPE_VALUE_ASCII_GET( v) ( ND_INDEX_TYPE_VALUE_UNKNOWN_IS( (v)) ? "UNKNOWN" : ( ND_INDEX_TYPE_VALUE_LIST_IS( (v)) ? "LIST" : ( ND_INDEX_TYPE_VALUE_TREE_IS( (v)) ? "TREE" : "???"))) + +#define ND_INDEX_TYPE_ASCII_GET( r, i) ND_INDEX_TYPE_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type) + + + +#define NDD_INDEX_SUBTYPE_UNKNOWN 0x0000 +#define NDD_INDEX_SUBTYPE_FIFO 0x0100 /* principe de la file d'attente (First In First Out) */ +#define NDD_INDEX_SUBTYPE_LILO NDD_INDEX_SUBTYPE_FIFO +#define NDD_INDEX_SUBTYPE_LIFO 0x0200 /* principe de la pile (First In Last Out) */ +#define NDD_INDEX_SUBTYPE_FILO NDD_INDEX_SUBTYPE_LIFO +#define NDD_INDEX_SUBTYPE_SORTED 0x0300 /* liste triée */ +#define NDD_INDEX_SUBTYPE_UNBALANCED 0x0400 +#define NDD_INDEX_SUBTYPE_BALANCED 0x0500 /* arbre auto-équilibré */ +#define NDD_INDEX_SUBTYPE_MSK ( NDD_INDEX_SUBTYPE_UNKNOWN | NDD_INDEX_SUBTYPE_FIFO | NDD_INDEX_SUBTYPE_FILO | NDD_INDEX_SUBTYPE_SORTED | NDD_INDEX_SUBTYPE_UNBALANCED | NDD_INDEX_SUBTYPE_BALANCED) +#define NDD_INDEX_SUBTYPE_RMSK (NDD_INDEX_MSK ^ NDD_INDEX_SUBTYPE_MSK) + +#define ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNKNOWN) +#define ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_FIFO) +#define ND_INDEX_SUBTYPE_VALUE_LILO_IS( v) ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) +#define ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_LIFO) +#define ND_INDEX_SUBTYPE_VALUE_FILO_IS( v) ND_INDEX_SUBTYPE_LIFO_IS( r, i) +#define ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_SORTED) +#define ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNBALANCED) +#define ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_BALANCED) + +#define ND_INDEX_SUBTYPE_UNKNOWN_IS( r, i) ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_FIFO_IS( r, i) ND_INDEX_SUBTYPE_VALUE_FIFO_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_LILO_IS( r, i) ND_INDEX_SUBTYPE_VALUE_LILO_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_LIFO_IS( r, i) ND_INDEX_SUBTYPE_VALUE_LIFO_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_FILO_IS( r, i) ND_INDEX_SUBTYPE_VALUE_FILO_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_SORTED_IS( r, i) ND_INDEX_SUBTYPE_VALUE_SORTED_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_UNBALANCED_IS( r, i) ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( (r)->Index_Tab[(i)].Type) +#define ND_INDEX_SUBTYPE_BALANCED_IS( r, i) ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( (r)->Index_Tab[(i)].Type) + +#define ND_INDEX_SUBTYPE_VALUE_ASCII_GET( v) ( ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v) ? "UNKNOWN" : ( ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) ? "FIFO" : ( ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v) ? "LIFO" : ( ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v) ? "SORTED" : ( ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v) ? "UNBALANCED" : ( ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v) ? "BALANCED" : "???")))))) +#define ND_INDEX_SUBTYPE_ASCII_GET( r, i) ND_INDEX_SUBTYPE_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type) -#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; +typedef int NDT_Command; + +#define NDD_CMD_UNKNOWN (NDT_Command)0 +#define NDD_CMD_MANAGER_VERSION (NDT_Command)1 +#define NDD_CMD_INDEX_GET (NDT_Command)2 +#define NDD_CMD_VALUE_ALLOC (NDT_Command)3 +#define NDD_CMD_VALUE_FREE (NDT_Command)4 +#define NDD_CMD_VALUE_COMP (NDT_Command)5 +#define NDD_CMD_VALUE_ADD (NDT_Command)6 +#define NDD_CMD_VALUE_REMOVE (NDT_Command)7 +#define NDD_CMD_VALUE_PRINT (NDT_Command)8 +#define NDD_CMD_VALUE_FIND (NDT_Command)9 +#define NDD_CMD_INFO_PRINT (NDT_Command)10 + +#define NDD_CMD_USER_TRAVERSE (NDT_Command)17 + + +typedef char *NDT_Command_Name; +typedef char *NDT_Version_Name; + -#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 */ @@ -78,49 +174,140 @@ typedef int NDT_Status; #define NDS_ERRMEM -1 /* Problème d'allocation mémoire */ #define NDS_ERRAPI -2 /* Utilisation incorrecte des API */ + + +typedef short NDT_Index_Id; +typedef short NDT_Index_Nb; + +#define NDD_INDEX_UNKNOWN (NDT_Index_Id)-1 +#define NDD_INDEX_PRIMARY (NDT_Index_Id)0 + + + +struct NDT_Root; +struct NDT_Node; + + + /* Pointeur de fonction sur le manager */ -typedef NDT_Status NDT_Manager (va_list); +#define NDD_MANAGER_NAME_LEN_MAX 64 +#define NDD_MANAGER_NAME_SIZE_MAX (NDD_MANAGER_NAME_LEN_MAX + 1) + +typedef char *NDT_Manager_Name; + +typedef NDT_Status NDT_Manager( struct NDT_Root *, NDT_Index_Id, struct NDT_Node *, NDT_Command, va_list); + /* Pointeur de fonction sur l'allocateur */ -typedef NDT_Status NDT_Allocator (size_t, void **, void *); +#define NDD_ALLOCATOR_NAME_LEN_MAX 64 +#define NDD_ALLOCATOR_NAME_SIZE_MAX (NDD_ALLOCATOR_NAME_LEN_MAX + 1) + +typedef char *NDT_Allocator_Name; + +typedef NDT_Status NDT_Allocator(size_t, void **, void *); + /* Pointeur de fonction sur le désallocateur */ -typedef NDT_Status NDT_Desallocator (void *, void *); +#define NDD_DESALLOCATOR_NAME_LEN_MAX 64 +#define NDD_DESALLOCATOR_NAME_SIZE_MAX (NDD_DESALLOCATOR_NAME_LEN_MAX + 1) -/* Structure racine */ +typedef char *NDT_Desallocator_Name; + +typedef NDT_Status NDT_Desallocator(void *, void *); + + + + +typedef struct NDT_Index +{ + NDT_Index_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 */ + struct NDT_Node * Head; /* Noeud de tête */ + struct NDT_Node * Tail; /* Noeud de queue */ + struct NDT_Node * Save; /* Pointeur de sauvegarde (utile pour la fonction de restauration) */ + +} NDT_Index; + + + +typedef struct NDT_Root +{ +// NDT_Root_Type Type; /* Root Structure Type */ +// NDT_DataStruct_Type DS_Type; /* Type de la structure (liste, arbre ... ) */ + + NDT_Manager *Manager_Ptr; /* Pointeur sur la fonction manager */ + char Manager_Name[NDD_MANAGER_NAME_SIZE_MAX]; /* Nom de la fonction manager */ + NDT_Allocator *Allocator_Ptr; /* Pointeur sur la fonction d'allocation */ + char Allocator_Name[NDD_ALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction d'allocation */ + NDT_Desallocator *Desallocator_Ptr; /* Pointeur sur la fonction de désallocation */ + char Desallocator_Name[NDD_DESALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction de désallocation */ + + short Own_Value; /* Indique si la structure est propriétaire de ses valeurs */ + void *User; /* Pointeur utilisable librement par l'utilisateur */ + + NDT_Index_Nb Index_Nb; + NDT_Index_Nb Index_Open_Nb; + NDT_Index Index_Tab[0]; -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; + + +typedef struct NDT_DataStruct +{ + + NDT_Root *Root_Ptr; + + NDT_Manager *Manager_Ptr; /* Manager function pointer */ + NDT_Allocator *Allocator_Ptr; /* Allocator function pointer */ + NDT_Desallocator *Desallocator_Ptr; /* Desallocator function pointer */ + +} NDT_DataStruct; + + + /* 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; +typedef struct NDT_Node +{ + NDT_Root *Root; + NDT_Index_Id Index; + struct NDT_Node *Parent; + struct NDT_Node *Left; + struct NDT_Node *Right; + void *Value; } NDT_Node; + + char ND_Error_Msg [512]; + + +typedef int NDT_Recursive_Mode; +typedef int NDT_Recursive_Depth; +typedef int NDT_Recursive_Offset; + +#define NDD_RECURSIVE_MODE_UNKNOWN (NDT_Recursive_Mode)0x00 +#define NDD_RECURSIVE_MODE_PARENT (NDT_Recursive_Mode)0x01 +#define NDD_RECURSIVE_MODE_CHILD (NDT_Recursive_Mode)0x02 +#define NDD_RECURSIVE_MODE_PARENT_CHILD (NDT_Recursive_Mode)0x03 + +#define ND_RECURSIVE_PARENT_IS(m) (m & NDD_RECURSIVE_MODE_PARENT) +#define ND_RECURSIVE_CHILD_IS(m) (m & NDD_RECURSIVE_MODE_CHILD) + +#define ND_RECURSIVE_PRINT_OFFSET 8 + + + /* Définition des alias de l'API */ #ifndef ND_MODE @@ -132,27 +319,47 @@ char ND_Error_Msg [512]; #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_Flush ND_DataStruct_Flush_I #define ND_DataStruct_Check ND_DataStruct_Check_I -#define ND_DataStruct_Dump ND_DataStruct_Dump_I +#define ND_DataStruct_Convert ND_DataStruct_Convert_I +#define ND_DataStruct_Reorg ND_DataStruct_Reorg_I +#define ND_DataStruct_Traverse_V ND_DataStruct_Traverse_VI +#define ND_DataStruct_Traverse ND_DataStruct_Traverse_I +#define ND_DataStruct_Info_Print ND_DataStruct_Info_Print_I +#define ND_DataStruct_Value_Add ND_DataStruct_Value_Add_I +#define ND_DataStruct_Value_Remove ND_DataStruct_Value_Remove_I +#define ND_DataStruct_Value_Print ND_DataStruct_Value_Print_I +#define ND_DataStruct_Value_Find ND_DataStruct_Value_Find_I + +#define ND_Index_Open ND_Index_Open_I +#define ND_Index_Close ND_Index_Close_I +#define ND_Index_Flush ND_Index_Flush_I +#define ND_Index_Check ND_Index_Check_I +#define ND_Index_Convert ND_Index_Convert_I +#define ND_Index_Reorg ND_Index_Reorg_I +#define ND_Index_Traverse_V ND_Index_Traverse_VI +#define ND_Index_Traverse ND_Index_Traverse_I +#define ND_Index_Info_Print ND_Index_Info_Print_I +#define ND_Index_Value_Add ND_Index_Value_Add_I +#define ND_Index_Value_Remove ND_Index_Value_Remove_I +#define ND_Index_Value_Print ND_Index_Value_Print_I +#define ND_Index_Node_Add ND_Index_Node_Add_I +#define ND_Index_Node_Remove ND_Index_Node_Remove_I +#define ND_Index_Node_First_Get ND_Index_Node_First_Get_I +#define ND_Index_Node_Last_Get ND_Index_Node_Last_Get_I +#define ND_Index_Node_Next_Get ND_Index_Node_Next_Get_I +#define ND_Index_Node_Previous_Get ND_Index_Node_Previous_Get_I +#define ND_Index_Node_Find ND_Index_Node_Find_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_V ND_Manager_Exec_VI #define ND_Manager_Exec ND_Manager_Exec_I #define ND_Allocator_Exec ND_Allocator_Exec_I #define ND_Desallocator_Exec ND_Desallocator_Exec_I @@ -162,50 +369,78 @@ char ND_Error_Msg [512]; #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_Flush ND_DataStruct_Flush_C #define ND_DataStruct_Check ND_DataStruct_Check_C -#define ND_DataStruct_Dump ND_DataStruct_Dump_C +#define ND_DataStruct_Convert ND_DataStruct_Convert_C +#define ND_DataStruct_Reorg ND_DataStruct_Reorg_C +#define ND_DataStruct_Traverse_V ND_DataStruct_Traverse_VC +#define ND_DataStruct_Traverse ND_DataStruct_Traverse_C +#define ND_DataStruct_Info_Print ND_DataStruct_Info_Print_C +#define ND_DataStruct_Value_Add ND_DataStruct_Value_Add_C +#define ND_DataStruct_Value_Remove ND_DataStruct_Value_Remove_C +#define ND_DataStruct_Value_Print ND_DataStruct_Value_Print_C +#define ND_DataStruct_Value_Find ND_DataStruct_Value_Find_C + +#define ND_Index_Open ND_Index_Open_C +#define ND_Index_Close ND_Index_Close_C +#define ND_Index_Flush ND_Index_Flush_C +#define ND_Index_Check ND_Index_Check_C +#define ND_Index_Convert ND_Index_Convert_C +#define ND_Index_Reorg ND_Index_Reorg_C +#define ND_Index_Traverse_V ND_Index_Traverse_VC +#define ND_Index_Traverse ND_Index_Traverse_C +#define ND_Index_Info_Print ND_Index_Info_Print_C +#define ND_Index_Value_Add ND_Index_Value_Add_C +#define ND_Index_Value_Remove ND_Index_Value_Remove_C +#define ND_Index_Value_Print ND_Index_Value_Print_C +#define ND_Index_Node_Add ND_Index_Node_Add_C +#define ND_Index_Node_Remove ND_Index_Node_Remove_C +#define ND_Index_Node_First_Get ND_Index_Node_First_Get_C +#define ND_Index_Node_Last_Get ND_Index_Node_Last_Get_C +#define ND_Index_Node_Next_Get ND_Index_Node_Next_Get_C +#define ND_Index_Node_Previous_Get ND_Index_Node_Previous_Get_C +#define ND_Index_Node_Find ND_Index_Node_Find_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_V ND_Manager_Exec_VC #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 ); +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 ); +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 */ @@ -217,74 +452,30 @@ NDT_Status ND_Library_Stderr_Set_C ( FILE * Out ); /* (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 ); +NDT_Status ND_DataStruct_Open_I( NDT_Root **, NDT_Index_Nb, NDT_Index_Type *, NDT_Manager_Name, NDT_Manager *, NDT_Allocator_Name, NDT_Allocator *, NDT_Desallocator_Name, NDT_Desallocator *, short, void *); +NDT_Status ND_DataStruct_Open_C( NDT_Root **, NDT_Index_Nb, NDT_Index_Type *, NDT_Manager_Name, NDT_Manager *, NDT_Allocator_Name, NDT_Allocator *, NDT_Desallocator_Name, NDT_Desallocator *, short, void *); + + /*------------------------------------------------------------------------------*/ /* 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 ); +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é */ +/* Destruction d'une structure de données */ /*------------------------------------------------------------------------------*/ -/* (I) Root: pointeur sur la racine de la structure de données */ +/* (O) 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 ); +NDT_Status ND_DataStruct_Flush_I( NDT_Root *Root); +NDT_Status ND_DataStruct_Flush_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 : */ @@ -296,81 +487,94 @@ NDT_Status ND_DataStruct_Print_C ( NDT_Root * Root, FILE * Out ); /* (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 ); +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 */ +/* 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 */ -/* (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 ); +NDT_Status ND_DataStruct_Reorg_I( NDT_Root *Root); +NDT_Status ND_DataStruct_Reorg_C( NDT_Root *Root); + + /*------------------------------------------------------------------------------*/ -/* Suppression d'un noeud dans une structure de données */ +/* Conversion d'une structure de données d'un type en un autre */ /*------------------------------------------------------------------------------*/ -/* (I) Node: pointeur sur le noeud à supprimer de la structure de données */ +/* (I) Root: pointeur sur la racine de la structure de données */ +/* (I) Target_Type: type de structure cible */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Node_Remove_I ( NDT_Node * Node); -NDT_Status ND_Node_Remove_C ( NDT_Node * Node); +NDT_Status ND_DataStruct_Convert_I( NDT_Root *, NDT_Index_Type *); +NDT_Status ND_DataStruct_Convert_C( NDT_Root *, NDT_Index_Type *); + + + +/*------------------------------------------------------------------------------*/ +/* 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_VI( NDT_Root *, NDT_Command Command, va_list); +NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *, NDT_Command Command, va_list); +NDT_Status ND_DataStruct_Traverse_I( NDT_Root *, NDT_Command Command, ...); +NDT_Status ND_DataStruct_Traverse_C( NDT_Root *, NDT_Command Command, ...); + + + +/*------------------------------------------------------------------------------*/ +/* 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( FILE *, NDT_Root *Root, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset); +NDT_Status ND_DataStruct_Info_Print_C( FILE *, NDT_Root *Root, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset); + + + +/*------------------------------------------------------------------------------*/ +/* 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_DataStruct_Value_Add_I( NDT_Root *Root, void *Value); +NDT_Status ND_DataStruct_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_DataStruct_Value_Remove_I( NDT_Root *Root, void *Value); +NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root *Root, void *Value); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Value_Print_VI( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list); +NDT_Status ND_DataStruct_Value_Print_I( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); +NDT_Status ND_DataStruct_Value_Print_C( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); + + /*------------------------------------------------------------------------------*/ /* Recherche un noeud à partir d'une valeur */ @@ -380,18 +584,114 @@ NDT_Status ND_Node_Remove_C ( NDT_Node * Node); /* (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 ); + +NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list); +NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list); +NDT_Status ND_DataStruct_Value_Find_I( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...); +NDT_Status ND_DataStruct_Value_Find_C( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...); + + /*------------------------------------------------------------------------------*/ -/* Allocation d'une valeur d'une structure de données */ +/* Create a new index (not yet implemented !) */ /*------------------------------------------------------------------------------*/ -/* (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 */ +/* (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_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ); -NDT_Status ND_Value_Alloc_C ( NDT_Root * Root, void ** Value, ... ); +NDT_Status ND_Index_Open_I( NDT_Root *, NDT_Index_Id, NDT_Index_Type); +NDT_Status ND_Index_Open_C( NDT_Root *, NDT_Index_Id, NDT_Index_Type); + + + +/*------------------------------------------------------------------------------*/ +/* Remove an Index (not yet implemented !) */ +/*------------------------------------------------------------------------------*/ +/* (O) Root: pointeur sur la racine de la structure de données */ +/*------------------------------------------------------------------------------*/ +NDT_Status ND_Index_Close_I( NDT_Root *, NDT_Index_Id); +NDT_Status ND_Index_Close_C( NDT_Root *, NDT_Index_Id); + + + +/*------------------------------------------------------------------------------*/ +/* Remove an Index (not yet implemented !) */ +/*------------------------------------------------------------------------------*/ +/* (O) Root: pointeur sur la racine de la structure de données */ +/*------------------------------------------------------------------------------*/ +NDT_Status ND_Index_Flush_I( NDT_Root *, NDT_Index_Id); +NDT_Status ND_Index_Flush_C( NDT_Root *, NDT_Index_Id); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Check_I( NDT_Root *Root, NDT_Index_Id, int *, int *, FILE *); +NDT_Status ND_Index_Check_C( NDT_Root *Root, NDT_Index_Id, int *, int *, FILE *); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Convert_I ( NDT_Root *, NDT_Index_Id Index_Id, NDT_Index_Type); +NDT_Status ND_Index_Convert_C ( NDT_Root *, NDT_Index_Id Index_Id, NDT_Index_Type); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Reorg_I( NDT_Root *, NDT_Index_Id); +NDT_Status ND_Index_Reorg_C( NDT_Root *, NDT_Index_Id); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Traverse_VI( NDT_Root *, NDT_Index_Id, NDT_Command, va_list); +NDT_Status ND_Index_Traverse_VC( NDT_Root *, NDT_Index_Id, NDT_Command, va_list); +NDT_Status ND_Index_Traverse_I( NDT_Root *, NDT_Index_Id, NDT_Command, ...); +NDT_Status ND_Index_Traverse_C( NDT_Root *, NDT_Index_Id, NDT_Command, ...); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Info_Print_I( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset); +NDT_Status ND_Index_Info_Print_C( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset); + + /*------------------------------------------------------------------------------*/ /* Ajout d'une valeur à une structure de données */ @@ -399,8 +699,10 @@ NDT_Status ND_Value_Alloc_C ( NDT_Root * Root, void ** Value, ... ); /* (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 ); +NDT_Status ND_Index_Value_Add_I( NDT_Root *Root, NDT_Index_Id, void *Value); +NDT_Status ND_Index_Value_Add_C( NDT_Root *Root, NDT_Index_Id, void *Value); + + /*------------------------------------------------------------------------------*/ /* Suppression du premier noeud correspondant à une valeur donnée */ @@ -409,8 +711,125 @@ NDT_Status ND_Value_Add_C ( NDT_Root * Root, void * Value ); /* (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 ); +NDT_Status ND_Index_Value_Remove_I( NDT_Root *Root, NDT_Index_Id, void *Value); +NDT_Status ND_Index_Value_Remove_C( NDT_Root *Root, NDT_Index_Id, void *Value); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Value_Print_VI( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list); +NDT_Status ND_Index_Value_Print_I( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); +NDT_Status ND_Index_Value_Print_C( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Node_Add_I( NDT_Root * Root, NDT_Index_Id Index_Id, NDT_Node * Node ); +NDT_Status ND_Index_Node_Add_C( NDT_Root * Root, NDT_Index_Id Index_Id, 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_Index_Node_Remove_I( NDT_Node * Node); +NDT_Status ND_Index_Node_Remove_C( 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_Index_Node_First_Get_I( NDT_Node **, NDT_Root *, NDT_Index_Id); +NDT_Status ND_Index_Node_First_Get_C( NDT_Node **, NDT_Root *, NDT_Index_Id); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Node_Last_Get_I( NDT_Node **, NDT_Root *, NDT_Index_Id); +NDT_Status ND_Index_Node_Last_Get_C( NDT_Node **, NDT_Root *, NDT_Index_Id); + + + +/*------------------------------------------------------------------------------*/ +/* 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_Index_Node_Next_Get_I( NDT_Node **, NDT_Node *); +NDT_Status ND_Index_Node_Next_Get_C( NDT_Node **, NDT_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_Index_Node_Previous_Get_I( NDT_Node **, NDT_Node *); +NDT_Status ND_Index_Node_Previous_Get_C( NDT_Node **, NDT_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_Index_Node_Find_VI( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, va_list); +NDT_Status ND_Index_Node_Find_VC( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, va_list); +NDT_Status ND_Index_Node_Find_I( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...); +NDT_Status ND_Index_Node_Find_C( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...); + + + +/*------------------------------------------------------------------------------*/ +/* 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 **, NDT_Node *); +NDT_Status ND_Node_Root_Get_C( NDT_Root **, NDT_Node *); + + + +/*------------------------------------------------------------------------------*/ +/* 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 *, void **, ...); +NDT_Status ND_Value_Alloc_C( NDT_Root *, void **, ...); + + /*------------------------------------------------------------------------------*/ /* Désallocation d'une valeur d'une structure de données */ @@ -418,16 +837,22 @@ NDT_Status ND_Value_Remove_C ( NDT_Root * Root, void * Reference_Value, void ** /* (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 ); +NDT_Status ND_Value_Free_I( NDT_Root *, void *); +NDT_Status ND_Value_Free_C( NDT_Root *, void *); + + /*------------------------------------------------------------------------------*/ /* 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, ... ); +NDT_Status ND_Manager_Exec_VI( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); +NDT_Status ND_Manager_Exec_VC( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); +NDT_Status ND_Manager_Exec_I( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...); +NDT_Status ND_Manager_Exec_C( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...); + + /*------------------------------------------------------------------------------*/ /* Exécution d'une fonction d'allocation dont le nom est passé en paramètre */ @@ -437,10 +862,10 @@ NDT_Status ND_Manager_Exec_C ( const char * Function, ... ); /* (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 ); +NDT_Status ND_Allocator_Exec_I( NDT_Allocator *, void **, size_t, void *); +NDT_Status ND_Allocator_Exec_C( NDT_Allocator *, void **, size_t, void *); + + /*------------------------------------------------------------------------------*/ /* Exécution d'une fonction de désallocation le dont nom est passé en paramètre */ @@ -449,10 +874,10 @@ NDT_Status ND_Allocator_Exec_C ( const char * Function, void ** Ptr, \ /* (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 ); +NDT_Status ND_Desallocator_Exec_I( NDT_Desallocator *, void *, void *); +NDT_Status ND_Desallocator_Exec_C( NDT_Desallocator *, void *, void *); + + #ifdef __cplusplus }