901 lines
46 KiB
C
901 lines
46 KiB
C
/*---------------------------------------------------------------------------------*/
|
|
/* $RCSfile: node.h,v $ */
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* $Revision: 2.3 $ */
|
|
/* $Name: $ */
|
|
/* $Date: 2002/02/27 16:04:10 $ */
|
|
/* $Author: agibert $ */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#ifndef _LIBNODE_H_
|
|
#define _LIBNODE_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
#include <stdarg.h>
|
|
|
|
#ifdef _LIBVER_SUPPORT
|
|
# include <ver.h>
|
|
#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
|
|
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 short NDT_Root_Type;
|
|
|
|
typedef int NDT_Index_Type;
|
|
|
|
#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)
|
|
|
|
|
|
|
|
/* Commandes du manager */
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* Types de réponse du manager ou code retour des diverses fonctions */
|
|
|
|
typedef int NDT_Status;
|
|
|
|
#define ND_ERROR(s) ((s) <= 0) /* All negative or 0 status are errors */
|
|
|
|
#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 */
|
|
|
|
|
|
|
|
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 */
|
|
|
|
#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 */
|
|
|
|
#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 */
|
|
|
|
#define NDD_DESALLOCATOR_NAME_LEN_MAX 64
|
|
#define NDD_DESALLOCATOR_NAME_SIZE_MAX (NDD_DESALLOCATOR_NAME_LEN_MAX + 1)
|
|
|
|
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_Count;
|
|
NDT_Index Index_Tab[0];
|
|
|
|
} 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
|
|
{
|
|
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
|
|
#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_Flush ND_DataStruct_Flush_I
|
|
#define ND_DataStruct_Check ND_DataStruct_Check_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_Value_Alloc ND_Value_Alloc_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
|
|
|
|
#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_Flush ND_DataStruct_Flush_C
|
|
#define ND_DataStruct_Check ND_DataStruct_Check_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_Value_Alloc ND_Value_Alloc_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
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
|
|
# if defined(_MSC_VER) && !defined(LIBNODE_STATIC)
|
|
# ifndef _LIBNODE_C_
|
|
# define NDD_DLL_API __declspec(dllimport)
|
|
# else
|
|
# define NDD_DLL_API __declspec(dllexport)
|
|
# endif
|
|
# else
|
|
# define NDD_DLL_API
|
|
# endif
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Initialisation du contexte de la librairie */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Library_Open_I ( int Debug_Mode );
|
|
NDD_DLL_API NDT_Status ND_Library_Open_C ( int Debug_Mode );
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Fermeture du contexte de la librairie */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Library_Close_I( void);
|
|
NDD_DLL_API NDT_Status ND_Library_Close_C( void);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Définition de la sortie standard des messages d'erreur de la librairie */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Library_Stderr_Set_I( FILE *Out);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API 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 *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Close_I( NDT_Root *Root);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Close_C( NDT_Root *Root);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Destruction d'une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (O) Root: pointeur sur la racine de la structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Flush_I( NDT_Root *Root);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Flush_C( NDT_Root *Root);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Check_I( NDT_Root *Root, int *Nb_Detected, int *Nb_Corrected, FILE *Out);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Check_C( NDT_Root *Root, int *Nb_Detected, int *Nb_Corrected, 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Reorg_I( NDT_Root *Root);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Reorg_C( NDT_Root *Root);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Convert_I( NDT_Root *, NDT_Index_Type *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *, NDT_Command Command, va_list);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *, NDT_Command Command, va_list);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Traverse_I( NDT_Root *, NDT_Command Command, ...);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Info_Print_I( FILE *, NDT_Root *Root, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Add_I( NDT_Root *Root, void *Value);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Remove_I( NDT_Root *Root, void *Value);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_VI( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_I( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_I( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...);
|
|
NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_C( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Create a new index (not yet implemented !) */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Open_I( NDT_Root *, NDT_Index_Id, NDT_Index_Type);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Close_I( NDT_Root *, NDT_Index_Id);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Flush_I( NDT_Root *, NDT_Index_Id);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Check_I( NDT_Root *Root, NDT_Index_Id, int *, int *, FILE *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Convert_I ( NDT_Root *, NDT_Index_Id Index_Id, NDT_Index_Type);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Reorg_I( NDT_Root *, NDT_Index_Id);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Traverse_VI( NDT_Root *, NDT_Index_Id, NDT_Command, va_list);
|
|
NDD_DLL_API NDT_Status ND_Index_Traverse_VC( NDT_Root *, NDT_Index_Id, NDT_Command, va_list);
|
|
NDD_DLL_API NDT_Status ND_Index_Traverse_I( NDT_Root *, NDT_Index_Id, NDT_Command, ...);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Info_Print_I( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Value: pointeur sur la valeur à ajouter */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Value_Add_I( NDT_Root *Root, NDT_Index_Id, void *Value);
|
|
NDD_DLL_API NDT_Status ND_Index_Value_Add_C( NDT_Root *Root, NDT_Index_Id, 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Value_Remove_I( NDT_Root *Root, NDT_Index_Id, void *Value);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Value_Print_VI( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list);
|
|
NDD_DLL_API NDT_Status ND_Index_Value_Print_I( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Add_I( NDT_Root * Root, NDT_Index_Id Index_Id, NDT_Node * Node );
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Remove_I( NDT_Node * Node);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_First_Get_I( NDT_Node **, NDT_Root *, NDT_Index_Id);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Last_Get_I( NDT_Node **, NDT_Root *, NDT_Index_Id);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Next_Get_I( NDT_Node **, NDT_Node *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Previous_Get_I( NDT_Node **, NDT_Node *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Find_VI( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, va_list);
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Find_VC( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, va_list);
|
|
NDD_DLL_API NDT_Status ND_Index_Node_Find_I( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Node_Root_Get_I( NDT_Root **, NDT_Node *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Value_Alloc_I( NDT_Root *, void **, ...);
|
|
NDD_DLL_API NDT_Status ND_Value_Alloc_C( NDT_Root *, void **, ...);
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Value_Free_I( NDT_Root *, void *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Manager_Exec_VI( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
|
NDD_DLL_API NDT_Status ND_Manager_Exec_VC( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
|
NDD_DLL_API NDT_Status ND_Manager_Exec_I( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Allocator_Exec_I( NDT_Allocator *, void **, size_t, void *);
|
|
NDD_DLL_API 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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (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 */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDD_DLL_API NDT_Status ND_Desallocator_Exec_I( NDT_Desallocator *, void *, void *);
|
|
NDD_DLL_API NDT_Status ND_Desallocator_Exec_C( NDT_Desallocator *, void *, void *);
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|