diff --git a/include/datastr.h b/include/datastr.h index 6fdc20b..fdb8220 100644 --- a/include/datastr.h +++ b/include/datastr.h @@ -191,20 +191,58 @@ typedef struct DST_RootDescZ /* */ /*------------------------------------------------------------------------------*/ -#define DS_STRUCT_VALID_CHECK( Root_Ptr) \ - if( !DSD_DATASTRUCT_STATUS_VALUE_VALID( (Root_Ptr)->Status)) \ - { \ - DST_Status status; \ - int nb_detected = 0, nb_corrected = 0; \ - \ - \ - if( ( status = DS_DataStruct_Check_I( Root_Ptr, &nb_detected, &nb_corrected, DS_stderr)) != DSS_OK) \ - { \ - LG_LOG_ERROR_0( "Unable to check the data structure"); \ - \ - return( status); \ - } \ - } \ +#define DS_STRUCT_VALID_CHECK( Root_Ptr) \ + if( !DSD_DATASTRUCT_STATUS_VALUE_VALID( (Root_Ptr)->Status)) \ + { \ + DST_Status status; \ + int nb_detected = 0, nb_corrected = 0; \ + \ + \ + if( ( status = DS_DataStruct_Check_I( (Root_Ptr), &nb_detected, &nb_corrected, DS_stderr)) != DSS_OK) \ + { \ + LG_LOG_ERROR_0( "Unable to check the data structure"); \ + \ + return( status); \ + } \ + } + + + +/*------------------------------------------------------------------------------*/ +/* */ +/*------------------------------------------------------------------------------*/ + +#define DS_STRUCT_LOCK( Root_Ptr, Lock_Mode, Lock_Flag_Ptr) \ + { \ + DST_Status status; \ + \ + \ + if( ( status = DS_DataStruct_Lock_I( (Root_Ptr), (Lock_Mode), (Lock_Flag_Ptr))) != DSS_OK) \ + { \ + LG_LOG_ERROR_0( "Unable to lock the data structure"); \ + \ + return( status); \ + } \ + } + + + +/*------------------------------------------------------------------------------*/ +/* */ +/*------------------------------------------------------------------------------*/ + +#define DS_STRUCT_UNLOCK( Root_Ptr, Lock_Flag) \ + { \ + DST_Status status; \ + \ + \ + if( (Lock_Flag) && ( ( status = DS_DataStruct_Unlock_I( (Root_Ptr))) != DSS_OK)) \ + { \ + LG_LOG_ERROR_0( "Unable to unlock the data structure"); \ + \ + return( status); \ + } \ + } @@ -235,7 +273,6 @@ typedef struct DST_RootDescZ # define DS_DataStruct_Open DS_DataStruct_Open_I # define DS_DataStruct_Close DS_DataStruct_Close_I # define DS_DataStruct_Flush DS_DataStruct_Flush_I -# define DS_DataStruct_Reorg DS_DataStruct_Reorg_I # define DS_DataStruct_Check DS_DataStruct_Check_I # define DS_DataStruct_Convert DS_DataStruct_Convert_I # define DS_DataStruct_Reorg DS_DataStruct_Reorg_I @@ -618,17 +655,16 @@ DSD_API DST_Status SD_DataStruct_Value_Find_CL( void **Value_Ptr_Ptr, DST_Roo /*----------------------------------------------------------------------------*/ -/* Parcours de tous les noeuds d'une structure de données et exécution d'une */ -/* commande sur chacun d'eux */ +/* Traverse a data structure & execute a command on each node */ /*----------------------------------------------------------------------------*/ -/* (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 */ +/* (I) Root_Ptr: Data structure pointer */ +/* (I) Command: Manager command */ +/* (I) ...: User args */ /*----------------------------------------------------------------------------*/ -/* -DSD_API DST_Status DS_DataStruct_Traverse_I( NDT_Root * Root, NDT_Command Command, void * Data); -DSD_API DST_Status DS_DataStruct_Traverse_L( NDT_Root * Root, NDT_Command Command, void * Data); -DSD_API DST_Status DS_DataStruct_Traverse_CL( NDT_Root * Root, NDT_Command Command, void * Data); + +DSD_API DST_Status DS_DataStruct_Traverse_I( DST_Root *Root_Ptr, NDT_Command Command, ...); +DSD_API DST_Status DS_DataStruct_Traverse_L( DST_Root *Root_Ptr, NDT_Command Command, ...); +DSD_API DST_Status DS_DataStruct_Traverse_CL( DST_Root *Root_Ptr, NDT_Command Command, ...); diff --git a/lib/libdatastr.c b/lib/libdatastr.c index 870156c..e3a8d2f 100644 --- a/lib/libdatastr.c +++ b/lib/libdatastr.c @@ -272,11 +272,7 @@ DST_Status DS_DataStruct_Open_I( DST_Root **Root_Ptr_Ptr, char *DS_Name, NDT /* Création de la node structure */ -/* - strncpy( rootdesc_tmp.Heap_Name, prefixed_name, DSD_NAME_LEN); - rootdesc_tmp.Heap_Name[ DSD_NAME_LEN] = '\0'; -*/ -// if( ( nd_status = ND_DataStruct_Open( Root_Ptr_Ptr, Index_Nb, Index_Type_Tab, Manager_Name, NULL, "DS_DataStruct_Alloc", NULL, "DS_DataStruct_Free", NULL, Own_Value, &rootdesc_tmp)) != NDS_OK) + if( ( nd_status = ND_DataStruct_Open( &nd_root_ptr, Index_Nb, Index_Type_Tab, Manager_Name, NULL, "DS_Allocator", NULL, "DS_Deallocator", NULL, Own_Value, &root_tmp)) != NDS_OK) { LG_LOG_ERROR_2( "Unable to create a new node structure in the existing heap: [%s], status: (%d)", heap_ptr->Name, nd_status); @@ -294,35 +290,7 @@ DST_Status DS_DataStruct_Open_I( DST_Root **Root_Ptr_Ptr, char *DS_Name, NDT return( SMS_KO); } - - /* Allocation de mémoire pour la description de la nouvelle data structure */ -/* - if( ( status = DS_DataStruct_Alloc( (void **)( &rootdesc_ptr), sizeof( DST_RootDesc), &rootdesc_tmp)) != DSS_OK) - { - LG_LOG_ERROR_2( "Unable to allocate memory for the data structure description for new heap: [%s], status: (%d)", heap_ptr->Name, status); -/* -Strange: why end the heap here ? - - if( ( sm_status = SM_Heap_End( prefixed_name)) != SMS_OK) - { - LG_LOG_ERROR_2( "Unable to remove the heap: [%s], status: (%d)", prefixed_name, sm_status); - } -*/ -/* - if( locked == TRUE) - { - if( ( sm_status = SM_Heap_Unlock( heap_ptr)) != SMS_OK) - { - LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", heap_ptr->Name, sm_status); - } - } - - *Root_Ptr_Ptr = NULL; - - return( status); - } -*/ - + /* Initialise root */ *Root_Ptr_Ptr = DSD_DS_ROOT_GET( nd_root_ptr); @@ -338,29 +306,6 @@ Strange: why end the heap here ? ( *Root_Ptr_Ptr)->ND_Root.User_Ptr = NULL; -// ( *Root_Ptr_Ptr)->Manager_Name = ( *Root_Ptr_Ptr)->Manager_Name; - - -/* - strncpy( rootdesc_ptr->Heap_Name, prefixed_name, DSD_NAME_LEN); - rootdesc_ptr->Heap_Name[ DSD_NAME_LEN] = '\0'; - rootdesc_ptr->Manager_Name = ( *Root_Ptr_Ptr)->Manager_Name; - - - /* On indique que la structure n'est pas propriétaire de son heap */ -/* - rootdesc_ptr->Heap_Owner = FALSE; - - - /* On indique que la structure est valide */ -/* - rootdesc_ptr->Valid = TRUE; - - - /* On rattache la desription de la data structure à la racine */ -/* - ( *Root_Ptr_Ptr)->User_Ptr = rootdesc_ptr; - /* Déverrouillage du heap */ @@ -423,40 +368,7 @@ Strange: why end the heap here ? /* La racine de la structure se trouve dans le premier chunk du premier segment du heap */ *Root_Ptr_Ptr = ( DST_Root *)( ( size_t)( dsh_ptr->Start) + sizeof( NDT_Node) + sizeof( SMT_Chunk)); -// *Root_Ptr_Ptr = (NDT_Root *)( ( size_t)( dsh_ptr->Start) + sizeof( NDT_Node) + sizeof( SMT_Chunk)); - - /* Chargement des fonctions manager de la structure */ -/* - rootdesc_ptr = (*Root_Ptr_Ptr)->User_Ptr; - - - if( !rootdesc_ptr) - { - LG_LOG_ERROR_1( "Data structure [%s] has no description defined", DS_Name); - - if( locked == TRUE) - { - if( ( sm_status = SM_Heap_Unlock( heap_ptr)) != SMS_OK) - { - LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", heap_ptr->Name, sm_status); - } - } - - *Root_Ptr_Ptr = NULL; - - return( DSS_ERRAPI); - } -/* - if( !RootDesc->Manager_Name || !dlopen (( const char *)(RootDesc->Manager_FileName), RTLD_LAZY | RTLD_GLOBAL)) - { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Open : unable to load the manager file %s of data structure \"%s\" (%s)", RootDesc->Manager_FileName == NULL ? "undefined" : (char *)(RootDesc->Manager_FileName), DS_Name, dlerror ()); - DS_Error_Print (); - if (Locked == TRUE) SM_Heap_Unlock (Heap); - *Root = NULL; - return DSS_ERRDLL; - } -*/ break; } @@ -490,11 +402,7 @@ Strange: why end the heap here ? /* Création de la structure de données dans le heap */ -/* - strncpy( rootdesc_tmp.Heap_Name, prefixed_name, DSD_NAME_LEN); - rootdesc_tmp.Heap_Name[ DSD_NAME_LEN] = '\0'; -*/ -// if( ( nd_status = ND_DataStruct_Open( Root_Ptr_Ptr, Index_Nb, Index_Type_Tab, Manager_Name, NULL, "DS_DataStruct_Alloc", NULL, "DS_DataStruct_Free", NULL, Own_Value, &rootdesc_tmp)) != NDS_OK) + if( ( nd_status = ND_DataStruct_Open( &nd_root_ptr, Index_Nb, Index_Type_Tab, Manager_Name, NULL, "DS_Allocator", NULL, "DS_Deallocator", NULL, Own_Value, &root_tmp)) != NDS_OK) { LG_LOG_ERROR_2( "Unable to create a new node structure in new heap: [%s], status: (%d)", heap_ptr->Name, nd_status); @@ -509,42 +417,6 @@ Strange: why end the heap here ? return( SMS_KO); } - - /* Allocation de mémoire pour la description de la structure */ -/* - if( ( status = DS_DataStruct_Alloc( (void **)( &rootdesc_ptr), sizeof( DST_RootDesc), &rootdesc_tmp)) != DSS_OK) - { - LG_LOG_ERROR_2( "Unable to allocate memory for the data structure description for new heap: [%s], status: (%d)", heap_ptr->Name, status); - - if( ( sm_status = SM_Heap_End( prefixed_name)) != SMS_OK) - { - LG_LOG_ERROR_2( "Unable to remove the heap: [%s], status: (%d)", prefixed_name, sm_status); - } - - *Root_Ptr_Ptr = NULL; - - return( status); - } - - strncpy( rootdesc_ptr->Heap_Name, prefixed_name, DSD_NAME_LEN); - rootdesc_ptr->Heap_Name[ DSD_NAME_LEN] = '\0'; - rootdesc_ptr->Manager_Name = ( *Root_Ptr_Ptr)->Manager_Name; - - - /* On indique que la structure est propriétaire du heap */ -/* - rootdesc_ptr->Heap_Owner = TRUE; - - - /* On indique que la structure est valide */ -/* - rootdesc_ptr->Valid = TRUE; - - - /* On rattache la desription de la data structure à la racine */ -/* - ( *Root_Ptr_Ptr)->User_Ptr = rootdesc_ptr; - /* Initialise root */ @@ -590,7 +462,6 @@ Strange: why end the heap here ? /* On incrémente le sémaphore qui compte le nombre de processus qui ouvrent la structure */ -// if( ( status = DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Open, 1)) != DSS_OK) if( ( status = DS_Semaphore_Operate( ( *Root_Ptr_Ptr)->OpenSemId, DS_SemOp_Open, 1)) != DSS_OK) { LG_LOG_ERROR_2( "Unable to incremente the semaphore of data structure: [%s], status: (%d)", DS_Name, status); @@ -605,7 +476,6 @@ Strange: why end the heap here ? if( mode == 3) { -// semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); semctl( ( *Root_Ptr_Ptr)->OpenSemId, 0, IPC_RMID, Sem_Ctl); if( ( sm_status = SM_Heap_End( prefixed_name)) != SMS_OK) @@ -615,7 +485,6 @@ Strange: why end the heap here ? } else { -// DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); DS_Semaphore_Operate( ( *Root_Ptr_Ptr)->OpenSemId, DS_SemOp_Close, 1); } @@ -641,7 +510,6 @@ Strange: why end the heap here ? if( mode == 3) { -// semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); semctl( ( *Root_Ptr_Ptr)->OpenSemId, 0, IPC_RMID, Sem_Ctl); if( ( sm_status = SM_Heap_End( prefixed_name)) != SMS_OK) @@ -651,7 +519,6 @@ Strange: why end the heap here ? } else { -// DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); DS_Semaphore_Operate( ( *Root_Ptr_Ptr)->OpenSemId, DS_SemOp_Close, 1); } @@ -679,7 +546,6 @@ Strange: why end the heap here ? if( mode == 3) { -// semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); semctl( ( *Root_Ptr_Ptr)->OpenSemId, 0, IPC_RMID, Sem_Ctl); if( ( sm_status = SM_Heap_End( prefixed_name)) != SMS_OK) @@ -689,7 +555,6 @@ Strange: why end the heap here ? } else { -// DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); DS_Semaphore_Operate( ( *Root_Ptr_Ptr)->OpenSemId, DS_SemOp_Close, 1); } @@ -719,7 +584,6 @@ Strange: why end the heap here ? if( mode == 3) { -// semctl( rootdesc_ptr->OpenSemId, 0, IPC_RMID, Sem_Ctl); semctl( ( *Root_Ptr_Ptr)->OpenSemId, 0, IPC_RMID, Sem_Ctl); if( ( sm_status = SM_Heap_End( prefixed_name)) != SMS_OK) @@ -729,7 +593,6 @@ Strange: why end the heap here ? } else { -// DS_Semaphore_Operate( rootdesc_ptr->OpenSemId, DS_SemOp_Close, 1); DS_Semaphore_Operate( ( *Root_Ptr_Ptr)->OpenSemId, DS_SemOp_Close, 1); } @@ -746,83 +609,6 @@ Strange: why end the heap here ? -/*----------------------------------------------------------------------------*/ -/* Verrouillage d'une structure de données */ -/*----------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Lock_Mode : type de verrou à poser sur la structure */ -/* (O) Locked : verrou effectif (TRUE ou FALSE) */ -/*----------------------------------------------------------------------------*/ - -DST_Status DS_DataStruct_Lock_I( DST_Root *Root_Ptr, DST_Flags Lock_Mode, int *Locked ) -{ -// char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name; - - SMT_Status sm_status; - SMT_Heap *heap_ptr; - - - /* Réouverture du heap sous-jacent (rafraîchissement des segments) + verrouillage */ - - if( ( sm_status = SM_Heap_Open( Root_Ptr->Heap_Name, &heap_ptr, 0, ( SMD_OPEN | Lock_Mode), Locked)) != SMS_OK) - { - LG_LOG_ERROR_3( "Unable to reopen the data structure heap: [%s] for [%s], status: (%d)", - Root_Ptr->Heap_Name, (DSD_MSK_READ( Lock_Mode) ? "reading" : "writing"), sm_status); - - return( DSS_KO); - } - - return( DSS_OK); -} - - - - - -/*----------------------------------------------------------------------------*/ -/* Déverrouillage d'une structure de données */ -/*----------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/*----------------------------------------------------------------------------*/ - -DST_Status DS_DataStruct_Unlock_I( DST_Root *Root_Ptr) -{ -// char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name; - - SMT_Status sm_status; - SMT_Heap *heap_ptr; - - - if( ( sm_status = SM_Heap_IsOpen( Root_Ptr->Heap_Name, &heap_ptr)) != SMS_OK) - { - LG_LOG_ERROR_2( "Unable to check if heap: [%s] is open, status: (%d)", Root_Ptr->Heap_Name, sm_status); - - return( DSS_KO); - } - else - { - if( heap_ptr == NULL) - { - LG_LOG_ERROR_1( "Data structure heap: [%s] is not open", Root_Ptr->Heap_Name); - - return( DSS_KO); - } - } - - if( ( sm_status = SM_Heap_Unlock( heap_ptr)) != SMS_OK) - { - LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", Root_Ptr->Heap_Name, sm_status); - - return( DSS_KO); - } - - return( DSS_OK); -} - - - - - /*----------------------------------------------------------------------------*/ /* Fermeture d'une structure de données */ /*----------------------------------------------------------------------------*/ @@ -1166,8 +952,6 @@ DST_Status DS_DataStruct_Check_I( DST_Root *Root_Ptr, int *Error_Detected_Nb DST_Status DS_DataStruct_Convert_I( DST_Root *Root_Ptr, NDT_Index_Type *Index_Type_Ptr) { -// DST_RootDesc *RootDesc_Ptr = (DST_RootDesc *)( Root_Ptr->User_Ptr); - DST_Status status; NDT_Status nd_status; @@ -1251,6 +1035,71 @@ DST_Status DS_DataStruct_Reorg_I( DST_Root *Root_Ptr) +/*----------------------------------------------------------------------------*/ +/* Traverse a data structure & execute a command on each node */ +/*----------------------------------------------------------------------------*/ +/* (I) Root_Ptr: Data structure pointer */ +/* (I) Command: Manager command */ +/* (I) ...: User args */ +/*----------------------------------------------------------------------------*/ + +DST_Status DS_DataStruct_Traverse_I( DST_Root *Root_Ptr, NDT_Command Command, ...) +{ + DST_Status status; + NDT_Status nd_status; + va_list user_args; + + + /* On vérifie que la data structure est valide */ + + DS_STRUCT_VALID_CHECK( Root_Ptr); + + + /* Récupération des arguments pour l'allocation de la valeur */ + + va_start( user_args, Command); + + + /* On rend éventuellement la structure invalide le temps de sa traversée */ + + switch( Command) + { + case NDD_CMD_VALUE_PRINT: + break; + + default: + Root_Ptr->Status = DSD_DATASTRUCT_STATUS_INVALID; + break; + } + + + /* Traversée de la node structure */ + + if( ( nd_status = ND_DataStruct_Traverse_VI( &( Root_Ptr->ND_Root), Command, &user_args)) != NDS_OK) + { + LG_LOG_ERROR_1( "Unable to traverse the node structure, status: (%d)", nd_status); + + status = DSS_KO; + } + else + { + status = DSS_OK; + } + + + /* On rend la structure valide */ + + Root_Ptr->Status = DSD_DATASTRUCT_STATUS_VALID; + + va_end( user_args); + + return( status); +} + + + + + /*----------------------------------------------------------------------------*/ /* Print data structure information */ /*----------------------------------------------------------------------------*/ @@ -1263,8 +1112,6 @@ DST_Status DS_DataStruct_Reorg_I( DST_Root *Root_Ptr) DST_Status DS_DataStruct_Info_Print_I( FILE *Out, DST_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset) { -// DST_RootDesc *RootDesc_Ptr = (DST_RootDesc *)( Root_Ptr->User_Ptr); - DST_Status status; NDT_Status nd_status; @@ -1275,7 +1122,7 @@ DST_Status DS_DataStruct_Info_Print_I( FILE *Out, DST_Root *Root_Ptr, NDT_Recu /* On vérifie que la data structure est valide */ -// DS_STRUCT_VALID_CHECK( Root_Ptr->ND_Root, RootDesc_Ptr); + DS_STRUCT_VALID_CHECK( Root_Ptr); /* Affichage des informations sur la structure */ @@ -1316,79 +1163,76 @@ DST_Status DS_DataStruct_Info_Print_I( FILE *Out, DST_Root *Root_Ptr, NDT_Recu /*----------------------------------------------------------------------------*/ -/* Parcours de tous les noeuds d'une structure de données et exécution d'une */ -/* commande sur chacun d'eux */ +/* Verrouillage d'une structure de données */ /*----------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données à parcourir*/ -/* (I) Command : commande à exécuter sur chaque noeud traversé */ -/* (I) Data : pointeur de données utilisateur */ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Lock_Mode : type de verrou à poser sur la structure */ +/* (O) Locked : verrou effectif (TRUE ou FALSE) */ /*----------------------------------------------------------------------------*/ -/* -DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, void * Data ) + +DST_Status DS_DataStruct_Lock_I( DST_Root *Root_Ptr, DST_Flags Lock_Mode, int *Locked ) { - DST_Status rc; - DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); +// char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name; - /* On vérifie que la data structure est valide */ -/* - if (RootDesc->Valid == FALSE) + SMT_Status sm_status; + SMT_Heap *heap_ptr; + + + /* Réouverture du heap sous-jacent (rafraîchissement des segments) + verrouillage */ + + if( ( sm_status = SM_Heap_Open( Root_Ptr->Heap_Name, &heap_ptr, 0, ( SMD_OPEN | Lock_Mode), Locked)) != SMS_OK) { - int nb_detected, nb_corrected; + LG_LOG_ERROR_3( "Unable to reopen the data structure heap: [%s] for [%s], status: (%d)", + Root_Ptr->Heap_Name, (DSD_MSK_READ( Lock_Mode) ? "reading" : "writing"), sm_status); - /* On vérifie la structure */ -/* - nb_detected = nb_corrected = 0; + return( DSS_KO); + } - if( ( status = DS_DataStruct_Check_L( Root_Ptr, &nb_detected, &nb_corrected, DS_stderr)) != DSS_OK) + return( DSS_OK); +} + + + + + +/*----------------------------------------------------------------------------*/ +/* Déverrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/*----------------------------------------------------------------------------*/ + +DST_Status DS_DataStruct_Unlock_I( DST_Root *Root_Ptr) +{ +// char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name; + + SMT_Status sm_status; + SMT_Heap *heap_ptr; + + + if( ( sm_status = SM_Heap_IsOpen( Root_Ptr->Heap_Name, &heap_ptr)) != SMS_OK) + { + LG_LOG_ERROR_2( "Unable to check if heap: [%s] is open, status: (%d)", Root_Ptr->Heap_Name, sm_status); + + return( DSS_KO); + } + else + { + if( heap_ptr == NULL) { - LG_LOG_ERROR_0( "Unable to check the data structure"); + LG_LOG_ERROR_1( "Data structure heap: [%s] is not open", Root_Ptr->Heap_Name); - return( status); + return( DSS_KO); } } - /* On rend éventuellement la structure invalide le temps de sa traversée */ -/* - switch ((int)Command) + if( ( sm_status = SM_Heap_Unlock( heap_ptr)) != SMS_OK) { - case NDD_CMD_PRINT_VALUE: - break; + LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", Root_Ptr->Heap_Name, sm_status); - default: - RootDesc->Valid = FALSE; - break; + return( DSS_KO); } - /* Traversée de la node structure */ -/* - rc = ND_DataStruct_Traverse (Root, Command, Data); - if (rc != NDS_OK) - { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Traverse : unable to traverse the node structure "); - DS_Error_Print (); - - if (!DS_ERROR(rc)) RootDesc->Valid = TRUE; - - return rc; - } - - /* On rend la structure valide */ -/* - RootDesc->Valid = TRUE; - - return DSS_OK; -} - -/*----------------------------------------------------------------------------*/ -/* Affichage d'une structure de données */ -/*----------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données à afficher */ -/* (I) Out : flux de sortie */ -/*----------------------------------------------------------------------------*/ -/* -DST_Status DS_DataStruct_Print_I ( NDT_Root * Root, FILE * Out ) -{ - return DS_DataStruct_Traverse_I (Root, NDD_CMD_PRINT_VALUE, Out); + return( DSS_OK); } @@ -2092,7 +1936,7 @@ DST_Status DS_Value_Alloc_I( void **Value_Ptr_Ptr, DST_Root *Root_Ptr, ... ) if( ( nd_status = ND_Manager_Exec( &( Root_Ptr->ND_Root), NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_ALLOC, Value_Ptr_Ptr, &user_args)) != NDS_OK) { - LG_LOG_ERROR_1( "Unnable to alloc a new value: (%d)", nd_status); + LG_LOG_ERROR_1( "Unable to alloc a new value, status: (%d)", nd_status); status = DSS_KO; } @@ -2304,30 +2148,27 @@ DST_Status DS_DataStruct_Check_L( DST_Root *Root_Ptr, int *Error_Detected_Nb /* (I) Root_Ptr: Data structure pointer */ /* (I) Index_Type_Ptr: Array of index type (List, tree, ...) */ /*----------------------------------------------------------------------------*/ -/* -DST_Status DS_DataStruct_Convert_L ( NDT_Root * Root, NDT_DataStruct_Type Target_Type ) + +DST_Status DS_DataStruct_Convert_L( DST_Root *Root_Ptr, NDT_Index_Type *Index_Type_Ptr) { - DST_Status rc; - int Locked; + DST_Status status; + int lock_flag; - /* Verrouillage de la data structure en écriture */ -/* - rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); - if (rc != DSS_OK) - { - sprintf (DS_Error_Msg, "Error DS_DataStruct_Convert : unable to lock the data structure for writing"); - DS_Error_Print (); + + /* Lock the data structure in write mode */ - return rc; - } + DS_STRUCT_LOCK( Root_Ptr, SMD_WRITE, &lock_flag); - rc = DS_DataStruct_Convert_I (Root, Target_Type); - /* Déverrouillage de la data structure si besoin */ -/* - if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); + status = DS_DataStruct_Convert_I( Root_Ptr, Index_Type_Ptr); - return rc; + + /* Unlock if needed Lock the data structure */ + + DS_STRUCT_UNLOCK( Root_Ptr, lock_flag); + + + return( status); }