libdatastr/util/dsbench.c

/*----------------------------------------------------------------------------*/
/* dsbench.c                                                                  */
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/* This file is part of LibDataStr.                                           */
/*                                                                            */
/*    LibDataStr is free software: you can redistribute it and/or modify it   */
/*    under the terms of the GNU General Public License as published by       */
/*    the Free Software Foundation, either version 3 of the License, or       */
/*    (at your option) any later version.                                     */
/*                                                                            */
/*    LibDataStr is distributed in the hope that it will be useful,           */
/*    but WITHOUT ANY WARRANTY; without even the implied warranty of          */
/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            */
/*    GNU General Public License for more details.                            */
/*                                                                            */
/*    You should have received a copy of the GNU General Public License       */
/*    along with LibDataStr. If not, see <https://www.gnu.org/licenses/>.     */
/*----------------------------------------------------------------------------*/



/*----------------------------------------------------------------------------*/
/* Includes                                                                   */
/*----------------------------------------------------------------------------*/

#define DS_MODE 2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <sys/time.h>

#include <log.h>
#include <node.h>
#include <datastr.h>





/*----------------------------------------------------------------------------*/
/* Defines                                                                    */
/*----------------------------------------------------------------------------*/

#define LGD_MODULE_NAME "dsb"

#define USAGE "Usage : %s [ --help | --batch_run <batch_file_name>]\n"

//extern char * strdup ( const char *);

#define QUIT                     0
#define LIB_OPEN                 1
#define LIB_CLOSE                2
#define DS_OPEN                  3
#define DS_CLOSE                 4
#define DS_FLUSH                 5
#define DS_CHECK                 6
#define DS_REORG                 7
#define DS_INFO_PRINT            8
#define DS_VALUE_ADD             9
#define DS_VALUE_REMOVE         10
#define DS_VALUE_PRINT          11
#define DS_VALUE_FIND           12
#define INDEX_LIST_OPEN         13
#define INDEX_TREE_OPEN         14
#define INDEX_CLOSE             15
#define INDEX_FLUSH             16
#define INDEX_CHECK             17
#define INDEX_LIST_SUBTYPE_SET  18
#define INDEX_LIST_TO_TREE      19
#define INDEX_TREE_SUBTYPE_SET  20
#define INDEX_TREE_TO_LIST      21
#define INDEX_REORG             22
#define INDEX_INFO_PRINT        23
#define INDEX_VALUE_PRINT       24
#define INDEX_VALUE_BREAK       25
#define INDEX_NODE_BREAK        26
#define BATCH_RUN               27

#define COMMAND_NB              28

#define INDEX_NB                32

/*
#define QUIT            0
#define CREATE_STRUCT   1
#define OPEN_STRUCT     2
#define CLOSE_STRUCT    3
#define DELETE_STRUCT   4
#define ADD_VALUE       5
#define REMOVE_VALUE    6
#define FIND_VALUE      7
#define CHG_LIST_TYPE   8
#define CONVERT_TO_TREE 9
#define CONVERT_TO_LIST 10
#define REORG           11
#define INFO            12
#define SHOW            13
#define CHECK           14

#define BATCH_RUN       27
*/

/*
char DataStruct_Name[ 100];
char menu [1000];
char buf [100];
long int random ( void );
*/

#define DS_STATE_UNKNOWN  0
#define DS_STATE_OPENED   1
#define DS_STATE_CLOSED   2



#define ARG_SIZE          ( 32 + 1)



#define BUF_LEN            99
#define BUF_SIZE           (BUF_LEN + 1)





/*----------------------------------------------------------------------------*/
/* Types                                                                      */
/*----------------------------------------------------------------------------*/

typedef struct Command
{

	short           id;
	char            Name[25];
	char            FullName[64];
	short           DS_State;
	NDT_Index_Type  Index_Type;

} Command;

typedef char  Arg[32 + 1];



/* Mesure des temps d'exécution */

typedef struct  cpt
{
	double          sec;
	struct timeval  start;
	struct timeval  stop;
}  cpt;



cpt  t_exec;


#define t_start(x)   { gettimeofday( &((x).start), NULL);}
#define t_stop(x)    { gettimeofday( &((x).stop), NULL); (x).sec = (double)((x).stop.tv_sec) - (double)((x).start.tv_sec) + ((double)((x).stop.tv_usec) - (double)((x).start.tv_usec)) / 1000000;}
#define seed_get(x)  (int)( (x).start.tv_sec)



/* Définition des valeurs attachées aux noeuds de la structure */

typedef struct  T_Module
{
    int   Id;
    char  Nom[ DSD_NAME_SIZE];
}  T_Module;



NDT_Index_Type  idx_type_tab[ INDEX_NB];

NDT_Index_Type  DBD_IDX_TYPE_FIFO          = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO;

NDT_Index_Type  DBD_IDX_TYPE_SORTED_LIST   = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED;

NDT_Index_Type  DBD_IDX_TYPE_BALANCED_TREE = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED;




/*----------------------------------------------------------------------------*/
/* Macros                                                                     */
/*----------------------------------------------------------------------------*/

#define DBD_ARG_READ( target_arg, local_arg, prompt_ptr)  fprintf( File_Output, (prompt_ptr)); \
                                                          fgets( buf, BUF_LEN, File_Input);    \
                                                          buf[ ( strlen( buf) - 1)] = '\0';    \
                                                          strcpy( (local_arg), buf);           \
                                                          (target_arg) = (local_arg);


#define DBD_ARG_COPY( target_arg, local_arg)          if( ( target_arg = malloc( ARG_SIZE)) != NULL) \
                                                          {                                          \
                                                              if( !strcmp( local_arg, "\"\""))        \
                                                              {                                      \
                                                                  target_arg[0] = '\0';              \
                                                              }                                      \
                                                              else                                   \
                                                              {                                      \
                                                                  strcpy( target_arg, local_arg);    \
                                                              }                                      \
                                                          }






/*----------------------------------------------------------------------------*/
/* Prototypes                                                                 */
/*----------------------------------------------------------------------------*/

NDT_Status  Module_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list  *);

void  Menu_Print( FILE  *, DST_Root  *);
void  Command_Get( int  *, char  **, char  **, char  **, FILE  *, FILE  *, short);
void  Command_Exec_Begin_Print( FILE  *, int);
void  Command_Exec_End_Print(   FILE  *, int, cpt, int);
void  Command_Index_Range_Get(  FILE  *, int  *, int  *, char  *, char  *, FILE  *, int, char  *);
void  Command_Exec( DST_Root  **, FILE  *, int, char  *, char  *, char  *, FILE  *);
void  Batch_Run(    DST_Root  **, FILE  *, FILE  *, short);





/*----------------------------------------------------------------------------*/
/* Global Variable                                                            */
/*----------------------------------------------------------------------------*/

Command  Command_Tab[] =
{
    { QUIT,                   "Quit",                   "Quit",                             ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { LIB_OPEN,               "Lib_Open",               "Open Library",                     ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { LIB_CLOSE,              "Lib_Close",              "Close Library",                    ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_OPEN,                "DS_Open",                "Open DataStructure",               ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_CLOSE,               "DS_Close",               "Close DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_FLUSH,               "DS_Flush",               "Flush DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_CHECK,               "DS_Check",               "Check DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_REORG,               "DS_Reorg",               "Reorg DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_INFO_PRINT,          "DS_Info_Print",          "Print DataStructure Informations", ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_ADD,           "DS_Value_Add",           "Add Values to DataStructure",      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_REMOVE,        "DS_Value_Remove",        "Remove Values from DataStructure", ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_PRINT,         "DS_Value_Print",         "Print DataStructure Values",       ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_FIND,          "DS_Value_Find",          "Find Values in DataStructure",     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_LIST_OPEN,        "Index_List_Open",        "Open List Index",                  ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_TREE_OPEN,        "Index_Tree_Open",        "Open Tree Index",                  ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_CLOSE,            "Index_Close",            "Close Index",                      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_FLUSH,            "Index_Flush",            "Flush  Index",                     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_CHECK,            "Index_Check",            "Check  Index",                     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_LIST_SUBTYPE_SET, "Index_List_SubType_Set", "Set List SubType",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST)},
    { INDEX_LIST_TO_TREE,     "Index_List_To_Tree",     "Convert List to Tree",             ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST)},
    { INDEX_TREE_SUBTYPE_SET, "Index_Tree_SubType_Set", "Set Tree SubType",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_TREE)},
    { INDEX_TREE_TO_LIST,     "Index_Tree_To_List",     "Convert Tree to List",             ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_TREE)},
    { INDEX_REORG,            "Index_Reorg",            "Reorg Index",                      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_INFO_PRINT,       "Index_Info_Print",       "Print Index Informations",         ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_VALUE_PRINT,      "Index_Value_Print",      "Print Index Values",               ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_VALUE_BREAK,      "Index_Value_Break",      "Break Index Value",                ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_NODE_BREAK,       "Index_Node_Break",       "Break Index Node",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { BATCH_RUN,              "Batch_Run",              "Run NDBench Bach",                 ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)}
};





/*---------------------------------------------------------------------------------*/
/* Module_Manager                                                                  */
/*---------------------------------------------------------------------------------*/

NDT_Status  Module_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  *Args_Ptr)
{
    NDT_Command_Name  Command_Name;
 
 
//    LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Manager command: (%d) called", Command);
             
     switch( Command)
     {
         case NDD_CMD_MANAGER_VERSION:
         {
             ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name  *);
 
 
             Command_Name = "NDD_CMD_MANAGER_VERSION";
 
             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             *Version_Name_Ptr = "Module Manager - DSBench";
 
             return( NDS_OK);
         }
 
         case NDD_CMD_INDEX_GET:
         {
             /*
               ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id  *);
               ND_VA_ARG_GET( Reply_Command_Ptr,  *Args_Ptr, NDT_Command  *);
               ND_VA_ARG_GET( Cmd,                *Args_Ptr, NDT_Command);
               ND_VA_ARG_GET( Value_Ptr,          *Args_Ptr, void  *);
             */
             ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id  *);
             ND_VA_ARG_GET( Reply_Command_Ptr,  *Args_Ptr, NDT_Command  *);
             ND_VA_ARG_GET( Cmd,                *Args_Ptr, NDT_Command);
             ND_VA_ARG_GET( Value_Ptr,          *Args_Ptr, void  *);
 
 
             Command_Name = "NDD_CMD_INDEX_GET";
 
             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             switch(Cmd)
             {
                 /*
                   case NDT_CMD_SOME_USER_CMD:
                   {
                   *Reply_Index_Id_Ptr = 0;
                   *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
                   break;
                   }
 
                   ...
                 */
 
                 default:
                 {
                     *Reply_Index_Id_Ptr = Index_Id;
                     *Reply_Command_Ptr = Cmd;
                     break;
                 }
             }
 
             return( NDS_OK);
         }
 
         case NDD_CMD_VALUE_ALLOC:
         {
             /*
               ND_VA_ARG_GET(    Value_Ptr_Ptr, *Args_Ptr, void  **);
 
               ND_VA_LIST_OPEN(  user_args,     *Args_Ptr);
 
               ND_VA_ARG_GET(    user_data,      user_args, user_type);
               ND_VA_ARG_GET(    ...,            user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
             */
 
             ND_VA_ARG_GET(    Module_Ptr_Ptr, *Args_Ptr, T_Module  **);

             ND_VA_LIST_OPEN(  user_args,     *Args_Ptr);
 
             ND_VA_ARG_GET(    Id,             user_args, int);
             ND_VA_ARG_GET(    Nom,            user_args, char      *);
 
             ND_VA_LIST_CLOSE( user_args);

             
             Command_Name = "NDD_CMD_VALUE_ALLOC";

             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);
             
 
             if( DS_Alloc( (void  **)Module_Ptr_Ptr, Root_Ptr, sizeof( T_Module)) != DSS_OK)
             {
                 LG_LOG_ERROR_0( "Allocation error");

                 return( DSS_KO);
             }
             else
             {                 
                 ( *Module_Ptr_Ptr)->Id  = Id;
                 strncpy( ( *Module_Ptr_Ptr)->Nom, Nom, DSD_NAME_LEN);
                 ( *Module_Ptr_Ptr)->Nom[ DSD_NAME_LEN] = '\0';

                 return( DSS_OK);
             }
         }
 
         case NDD_CMD_VALUE_FREE:
         {
             /*
               ND_VA_ARG_GET(    Value_Ptr, *Args_Ptr, void  *);
 
               ND_VA_LIST_OPEN(  user_args, *Args_Ptr);
 
               ND_VA_ARG_GET(    user_data,  user_args, user_type);
               ND_VA_ARG_GET(    ...,        user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
             */
  
             ND_VA_ARG_GET(    Module_Ptr_Ptr, *Args_Ptr, T_Module  **);

 
             Command_Name = "NDD_CMD_VALUE_FREE";

             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);
             
             return( DS_Free( Root_Ptr, Module_Ptr_Ptr));
         }
 
         case NDD_CMD_VALUE_COMP:
         {
             /*
               ND_VA_ARG_GET(    Value1_Ptr,  *Args_Ptr, void  *);
               ND_VA_ARG_GET(    Value2_Ptr,  *Args_Ptr, void  *);
 
               ND_VA_LIST_OPEN(  user_args,   *Args_Ptr);
 
               ND_VA_ARG_GET(    user_data,    user_args, user_type);
               ND_VA_ARG_GET(    ...,          user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
             */
 
             ND_VA_ARG_GET(    Value1_Ptr,  *Args_Ptr, T_Module  *);
             ND_VA_ARG_GET(    Value2_Ptr,  *Args_Ptr, T_Module  *);

             
             Command_Name = "NDD_CMD_VALUE_COMP";     

             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             
             switch( Index_Id)
             {
                 case 0:
                 {
                     if( Value1_Ptr->Id < Value2_Ptr->Id)
                     {
                         return( NDS_LOWER);
                     }
                     else
                     {
                         if( Value1_Ptr->Id > Value2_Ptr->Id)
                         {
                             return( NDS_GREATER);
                         }
                         else
                         {
                             return( NDS_EQUAL);
                         }
                     }
                 }
                 
                 default:
                 {
                     LG_LOG_ERROR_1( "Unknown comp index: (%d)", Index_Id);

                     return( NDS_KO);
                 }
             }
             
             return( NDS_OK);
         }
 
         case NDD_CMD_VALUE_ADD:
         {
             /*
               ND_VA_ARG_GET(    Value_Ptr, *Args_Ptr, void  *);
 
               ND_VA_LIST_OPEN(  user_args, *Args_Ptr);
 
               ND_VA_ARG_GET(    user_data,  user_args, user_type);
               ND_VA_ARG_GET(    ...,        user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
             */
 
 
             Command_Name = "NDD_CMD_VALUE_ADD";
 
             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             /*
               return( NDS_OK);
             */
         }
 
         case NDD_CMD_VALUE_REMOVE:
         {
             /*
               ND_VA_ARG_GET(   Value_Ptr, *Args_Ptr, void  *);
 
               ND_VA_LIST_OPEN( user_args, *Args_Ptr);
 
               ND_VA_ARG_GET(   user_data,  user_args, user_type);
               ND_VA_ARG_GET(   ...,        user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
             */

             Command_Name = "NDD_CMD_VALUE_REMOVE";

             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             return( NDS_OK);             
         }
 
         case NDD_CMD_VALUE_PRINT:
         {
             /*
               ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);
 
               ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);
 
               ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
               ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
               ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
               ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);
 
               ND_VA_LIST_OPEN(  user_args,         lib_args);
 
               ND_VA_ARG_GET(    user_data,         user_args, user_type);
               ND_VA_ARG_GET(    ...,               user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
               ND_VA_LIST_CLOSE( lib_args);
 
               void  *Value_Ptr = Node_Ptr->Value;
             */
 
             ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);
 
             ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);
 
             ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
             ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
             ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
             ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);
 
             ND_VA_LIST_CLOSE( lib_args);
             
             T_Module  *Module_Ptr = (T_Module  *)Node_Ptr->Value;

             
             Command_Name = "NDD_CMD_VALUE_PRINT";

             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             LG_LOG_INFO_2( "Id Module: (%d)   Nom Module: [%s]", Module_Ptr->Id, Module_Ptr->Nom);
             
             return( NDS_OK);
         }
 
         case NDD_CMD_INFO_PRINT:
         {
             /*
               ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);
 
               ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);
 
               ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
               ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
               ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
               ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);
 
               ND_VA_LIST_OPEN(  user_args,         lib_args);
 
               ND_VA_ARG_GET(    user_data,         user_args, user_type);
               ND_VA_ARG_GET(    ...,               user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
               ND_VA_LIST_CLOSE( lib_args);
             */
 
             ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);
 
             ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);
 
             ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
             ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
             ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
             ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);
 
             ND_VA_LIST_CLOSE( lib_args);

             char          *Root_Type;
//             DST_RootDesc  *RootDesc;
             
             
             Command_Name = "NDD_CMD_INFO_PRINT";
 
             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             return( NDS_OK);
         }
 
         case NDD_CMD_USER_TRAVERSE:
         {
             /*
               ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);
 
               ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);
 
               ND_VA_ARG_GET(    user_data,         user_args, user_type);
               ND_VA_ARG_GET(    ...,               user_args, ...);
 
               ND_VA_LIST_CLOSE( user_args);
 
 
               void  *Value_Ptr = Node_Ptr->Value;
             */
         
         
             Command_Name = "NDD_CMD_USER_TRAVERSE";
 
             LG_LOG_TRACE_1( LGD_LOG_LEVEL_DEFAULT, "Command: [%s] called", Command_Name);

             /*
               return( NDS_OK);
             */
         }
 
         default:
         {
             LG_LOG_ERROR_1( "Manager called with an undefined command: (%d)", Command);
             return( NDS_ERRAPI);
         }
     }
 
     LG_LOG_ERROR_2( "Manager internal error with command: (%d)  name: [%s]", Command, Command_Name);
     return( NDS_OK);
}





/*----------------------------------------------------------------------------*/
/* Menu_Print                                                                 */
/*----------------------------------------------------------------------------*/

void  Menu_Print( FILE  *File_Output, DST_Root  *DS_Ptr)
{
    short  i;
    char   headc;


    fprintf( File_Output, "\n-----------------------------------------------------------------------\nMenu :\n");

    for( i = 0; i < COMMAND_NB; i++)
    {
        if( ( DS_Ptr && ( Command_Tab[i].DS_State & DS_STATE_OPENED) && ( DS_Ptr->ND_Root.Index_Tab[0].Type & Command_Tab[i].Index_Type))
            || ( !DS_Ptr && ( Command_Tab[i].DS_State & DS_STATE_CLOSED)))
        {
            headc = '-';
        }
        else
        {
            headc = '*';
        }          
        
        fprintf( File_Output, "\t%c (%2d) [%s]%*s%s\n", headc, i, Command_Tab[i].Name, ( 25 - strlen(Command_Tab[i].Name)), " ", Command_Tab[i].FullName);
    }
}





/*----------------------------------------------------------------------------*/
/* Command_Get                                                                */
/*----------------------------------------------------------------------------*/

void  Command_Get( int  *choice, char  **Arg1, char  **Arg2, char  **Arg3, FILE  *File_Output, FILE  *File_Input, short  Interactive_Flag)
{
    char   buf[100];
    char  *tmp_arg1, *tmp_arg2, *tmp_arg3;


    do
    {
        if( Interactive_Flag)
        {
            fprintf( File_Output, "\nChoice ? ");
        }

        if( fgets( buf, BUF_LEN, File_Input) != NULL)
        {
            while( ( buf[ strlen( buf) - 1] == '\r') || ( buf[ strlen( buf) - 1] == '\n') || ( buf[ strlen( buf) - 1] == '\t') || ( buf[ strlen( buf) - 1] == ' '))
            {
                buf[ strlen( buf) - 1] = '\0';
            }

            if( buf[0] == '#')
            {
                *choice = -1;
            }
            else
            {
                if( isdigit( *buf))
                {
                    *choice = atoi( buf);
                }
                else
                {
                    for( *choice = 0; ( *choice < COMMAND_NB) && ( strncmp( buf, Command_Tab[*choice].Name, strlen(Command_Tab[*choice].Name))) ; (*choice)++);
                }
            }

            if( ( *choice < 0) || ( *choice >= COMMAND_NB))
            {
                if( *choice == -1)
                {
                    LG_LOG_INFO_1( "Skipping commented out line: [%s]", buf);
                }
                else
                {
//                    if( strlen( buf) != 0) fprintf( File_Output, "\nUndefined choice (%s) !\n", buf);
                    if( strlen( buf) != 0)
                    {
                        LG_LOG_ERROR_1( "Undefined choice: [%s]", buf);
                    }
                    
                    *choice = -1;
                }
                
                *Arg1 = NULL;
                *Arg2 = NULL;
                *Arg3 = NULL;
            }
            else
            {
                if( ( tmp_arg1 = strstr( buf, " ")) != NULL)
                {
                    tmp_arg1++;

                    if( ( tmp_arg2 = strstr( tmp_arg1, " ")) != NULL)
                    {
                        *tmp_arg2 = '\0';
                        tmp_arg2++;

                        if( ( tmp_arg3 = strstr( tmp_arg2, " ")) != NULL)
                        {
                            *tmp_arg3 = '\0';
                            tmp_arg3++;
/*                            
                            *Arg3 = malloc( ARG_SIZE);
                            if( *Arg3 != NULL) strcpy( *Arg3, tmp_arg3);
*/
                            DBD_ARG_COPY( *Arg3, tmp_arg3);
                        }
                        else
                        {
                            *Arg3 = NULL;
                        }
/*
                        *Arg2 = malloc( ARG_SIZE);
                        if( *Arg2 != NULL) strcpy( *Arg2, tmp_arg2);
*/
                        DBD_ARG_COPY( *Arg2, tmp_arg2);

                    }
                    else
                    {
                        *Arg2 = NULL;
                        *Arg3 = NULL;
                    }
/*
                    *Arg1 = malloc( ARG_SIZE);
                    if( *Arg1 != NULL) strcpy( *Arg1, tmp_arg1);                    
*/
                    DBD_ARG_COPY( *Arg1, tmp_arg1);
                }
                else
                {
                    *Arg1 = NULL;
                    *Arg2 = NULL;
                    *Arg3 = NULL;
                }
            }
        }
        else
        {
            *choice = 0;
            *Arg1 = NULL;
            *Arg2 = NULL;
            *Arg3 = NULL;
        }
    }
    while( *choice == -1);

    LG_LOG_INFO_3( "Arg1: [%s]   Arg2: [%s]   Arg3: [%s]", *Arg1, *Arg2, *Arg3);
}





/*----------------------------------------------------------------------------*/
/* Command_Exec_Begin_Print                                                   */
/*----------------------------------------------------------------------------*/

void  Command_Exec_Begin_Print( FILE  *File_Output, int  Choice)
{
    LG_LOG_INFO_2( "%s: %s...", Command_Tab[Choice].Name, Command_Tab[Choice].FullName);
}





/*----------------------------------------------------------------------------*/
/* Command_Exec_End_Print                                                     */
/*----------------------------------------------------------------------------*/

void  Command_Exec_End_Print( FILE  *File_Output, int  Choice, cpt  T_Exec, int  nb)
{
    if( nb == 1)
    {
	LG_LOG_INFO_2( "%s: Completed in (%.4f) second !", Command_Tab[Choice].Name, T_Exec.sec);
    }
    else
    {
	LG_LOG_INFO_3( "%s: Completed in (%.4f) second, (%.2f) per second !", Command_Tab[Choice].Name, T_Exec.sec, nb / T_Exec.sec);
    }
}





/*----------------------------------------------------------------------------*/
/* Command_Index_Range_Get                                                    */
/*----------------------------------------------------------------------------*/

void  Command_Index_Range_Get( FILE  *File_Output, int  *Low, int  *High, char  *Arg1, char  *Arg2, FILE  *File_Input, int  Choice, char  *Obj_Name)
{
    char   prompt[ 100], buf[ 100], local_arg1[ 100], local_arg2[ 100];
    char  *tmp;


    if( Arg1 == NULL)
    {
        snprintf( prompt, 100, "%s: %s range from: ", Command_Tab[Choice].Name, Obj_Name);
        DBD_ARG_READ( Arg1, local_arg1, prompt);
        
        snprintf( prompt, 100, "%s: %s range to: ",   Command_Tab[Choice].Name, Obj_Name);
        DBD_ARG_READ( Arg2, local_arg2, prompt);        
    }

    *Low  = atoi( Arg1);
    *High = atoi( Arg2);

    if( ( *High < *Low) || ( !strcmp( Obj_Name, "Index") && ( *High >= INDEX_NB)))
    {
        fprintf( File_Output, "%s: Invalit range (%d-%d) !\n", Command_Tab[Choice].Name, *Low, *High);
        *Low = *High = -1;
    }
}





/*----------------------------------------------------------------------------*/
/* Command_Exec                                                               */
/*----------------------------------------------------------------------------*/

void  Command_Exec( DST_Root  **DS_Ptr_Ptr, FILE  *File_Output, int  Choice, char  *Arg1, char  *Arg2, char  *Arg3, FILE  *File_Input)
{
    DST_Status       status;
    int              sub_choice_int1, sub_choice_int2, low, high, number, i, j, inc, nb_removed, nb_detected, nb_corrected;
    char            *sub_choice_str;
    T_Module         ref_module, *module_ptr;
    char             buf[ BUF_SIZE], local_arg1[ BUF_SIZE], local_arg2[ BUF_SIZE], local_arg3[ BUF_SIZE];
    NDT_Index_Type   index_subtype;


//    fprintf( File_Output, "\n");

    switch( Choice)
    {
        case QUIT:
        {
            break;
        }

        case LIB_OPEN:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

	    if( Arg1 == NULL)
	    {
                DBD_ARG_READ( Arg1, local_arg1, "Library_Open: Instance # (Default: 0): ");
                DBD_ARG_READ( Arg2, local_arg2, "Library_Open: Context (Default: ""): ");
                DBD_ARG_READ( Arg3, local_arg3, "Library_Open: Debug Mode (0:OFF | 1:ON): ");
	    }
            sub_choice_int1 = atoi(   Arg1);
            sub_choice_str  = strlen( Arg2) ? Arg2 : NULL;
            sub_choice_int2 = atoi(   Arg3);

            LG_LOG_TRACE_3( LGD_LOG_LEVEL_DEFAULT, "DS_Library_Open: Instance: (%d)   Contect: [%s]   Debug Mode: (%d)", sub_choice_int1, sub_choice_str, sub_choice_int2);

            t_start( t_exec);
            DS_Library_Open( sub_choice_int1, sub_choice_str, sub_choice_int2);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case LIB_CLOSE:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            DS_Library_Close();
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_OPEN:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

	    if( Arg1 == NULL)
	    {
                DBD_ARG_READ( Arg1, local_arg1, "DataStruct_Open: Name: ");
                DBD_ARG_READ( Arg2, local_arg2, "DataStruct_Open: Mode (0:Open | 1:Create): ");
	    }

	    sub_choice_str  = Arg1;
            sub_choice_int1 = atoi( Arg2);

            for( i = 0; i < INDEX_NB; i++)
            {
                idx_type_tab[i] = NDD_INDEX_STATUS_CLOSED;
            }

            LG_LOG_TRACE_2( LGD_LOG_LEVEL_DEFAULT, "DS_DataStruct_Open: Name: [%s]   Open Mode: (%d)", sub_choice_str, sub_choice_int1);

            t_start( t_exec);
            
            if( ( status = DS_DataStruct_Open( DS_Ptr_Ptr, sub_choice_str, INDEX_NB, idx_type_tab, "Module_Manager", 0, ( sub_choice_int1 ? DSD_CREATE : DSD_OPEN), TRUE)) != DSS_OK)
            {
                LG_LOG_ERROR_2( "Can't open data structure: [%s], status: (%d)", sub_choice_str, status);
            }
            else
            {                                
                LG_LOG_INFO_1( "Data structure: [%s] opened", sub_choice_str);
            }
                
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_CLOSE:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);

            if( ( status = DS_DataStruct_Close( *DS_Ptr_Ptr, DSD_CLOSE)) != DSS_OK)
            {
                LG_LOG_ERROR_1( "Can't close data structure, status: (%d)", status);
            }
            else
            {
                LG_LOG_INFO_0( "Data structure closed");
                *DS_Ptr_Ptr = NULL;
            }
            
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_FLUSH:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            
            if( ( status = DS_DataStruct_Flush( *DS_Ptr_Ptr)) != DSS_OK)
            {
                LG_LOG_ERROR_1( "Can't flush data structure, status: (%d)", status);
            }
            else
            {
                LG_LOG_INFO_0( "Data structure flushed");
            }
            
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_CHECK:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            nb_corrected = nb_detected = 0;

            t_start( t_exec);
            DS_DataStruct_Check( *DS_Ptr_Ptr, &nb_detected, &nb_corrected, File_Output);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_REORG:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            DS_DataStruct_Reorg( *DS_Ptr_Ptr);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_INFO_PRINT:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);

            DS_DataStruct_Info_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);

            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_VALUE_ADD:
        {
            int  order;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Value");

	    if( low != -1)
	    {
		if( Arg3 == NULL)
		{
                    DBD_ARG_READ( Arg3, local_arg3, "DS_Value_Add: Add order ( 0:croissant | 1:decroissant): ");
		}

		order = atoi( Arg3);


                LG_LOG_INFO_3( "DS_Value_Add: Adding from: (%d)   to: (%d)    order: (%d)...", low, high, order);

                
		if( order == 0)
		{
		    i   = low;
		    j   = high + 1;
                    inc = 1;
                }
                else
		{
		    i   = high;
		    j   = low - 1;
                    inc = -1;
                }                  
                    
		t_start( t_exec);

                while( i != j)
                {
                    char  tmp_name[ DSD_NAME_SIZE];

                    snprintf( tmp_name, DSD_NAME_LEN, "Element #: (%ld)", i);
                    tmp_name[ DSD_NAME_LEN] = '\0';
                    
                    if( DS_Value_Alloc( (void  **)&module_ptr, *DS_Ptr_Ptr, i, tmp_name) != DSS_OK)
                    {
                        LG_LOG_ERROR_0( "DS_Value_Add: Allocation Failled !");
                        
                        break;
                    }
                    else
                    {
                        DS_DataStruct_Value_Add( *DS_Ptr_Ptr, module_ptr);
                    }
                    
                    i += inc;
                }

                t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case DS_VALUE_REMOVE:
        {
            int  order;
            nb_removed = 0;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Value");

	    if( low != -1)
	    {
		if( Arg3 == NULL)
		{
                    DBD_ARG_READ( Arg3, local_arg3, "Remove ( 0:croissant | 1:decroissant): ");
		}

		order = atoi( Arg3);

		if( order == 0)
		{
		    i   = low;
		    j   = high + 1;
                    inc = 1;
                }
                else
		{
		    i   = high;
		    j   = low - 1;
                    inc = -1;
                }                  

		t_start( t_exec);

                while( i != j)
                {                  
                    ref_module.Id = i;
                    
                    if( ( DS_DataStruct_Value_Find( (void  **)&module_ptr, *DS_Ptr_Ptr, &ref_module) == DSS_OK) && ( module_ptr != NULL))
                    {
                        if( DS_DataStruct_Value_Remove( *DS_Ptr_Ptr, (void  *)module_ptr) == NDS_OK)
                        {
                            nb_removed++;
                            
                            if( DS_Value_Free( *DS_Ptr_Ptr, module_ptr) != DSS_OK)
                            {
                                LG_LOG_ERROR_0( "DS_Value_Remove: Deallocation Failled !");
                                
                                break;
                            }
                        }
                    }
                    
                    i += inc;
                }

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case DS_VALUE_PRINT:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            if( ( status = DS_DataStruct_Value_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0)) != DSS_OK)
            {
                LG_LOG_ERROR_1( "Unable to print data structure values, status: (%d)", status);
            }
            
            break;
        }

        case DS_VALUE_FIND:
        {
            int  repeat;

            
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Search");

	    if( low != -1)
	    {
                if( Arg3 == NULL)
                {
                    DBD_ARG_READ( Arg3, local_arg3, "Repeat #: ");
                }
                
                repeat = atoi(   Arg3);

		LG_LOG_INFO_3( "DS_Value_Find: from: (%d)   to: (%d)   repeat: (%d)...", low, high, repeat);

                number = ( high - low + 1) * repeat;

		t_start( t_exec);

                for( i = 0; i < number; i++)
                {
		    ref_module.Id = low + (int)( (double)( high - low) * rand() / ( RAND_MAX + 1.0));
                    
		    if( DS_DataStruct_Value_Find( (void  *)&module_ptr, *DS_Ptr_Ptr, &ref_module) != DSS_OK)
                    {
                        LG_LOG_ERROR_0( "DS_Value_Find: Search Failled !");
                        
                        break;
                    }
		}

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, number);
	    }

            break;
        }

        case INDEX_LIST_OPEN:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
		LG_LOG_INFO_2( "Index_List_Open: Opening a FIFO List from: (%d)   to: (%d)...", low, high);

		t_start( t_exec);

		for( i  = low; i <= high; i++)
		{
		    if( ( status = DS_Index_Open( *DS_Ptr_Ptr, (NDT_Index_Id)i, DBD_IDX_TYPE_FIFO)) != DSS_OK)
                    {
                        LG_LOG_ERROR_2( "Unable to open index: (%d), status: (%d)", i, status);

                        break;
                    }
		}

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_TREE_OPEN:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                LG_LOG_INFO_2( "Index_Tree_Open: Opening a balanced Tree from: (%d)   to: (%d)...", low, high);

                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
		    if( ( status = DS_Index_Open( *DS_Ptr_Ptr, (NDT_Index_Id)i, DBD_IDX_TYPE_BALANCED_TREE)) != DSS_OK)
                    {
                        LG_LOG_ERROR_2( "Unable to open index: (%d), status: (%d)", i, status);

                        break;
                    }
		}

                t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_CLOSE:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                LG_LOG_INFO_2( "Index_Close: Closing index from: (%d)   to: (%d)...", low, high);

                t_start( t_exec);

                for( i  = high; i >= low; i--)
                {
		    if( ( status = DS_Index_Close( *DS_Ptr_Ptr, (NDT_Index_Id)i)) != DSS_OK)
                    {
                        LG_LOG_ERROR_2( "Unable to close index: (%d), status: (%d)", i, status);

                        break;
                    }
      	        }

                t_stop( t_exec);

                Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
            }

            break;
        }

        case INDEX_LIST_SUBTYPE_SET:
        {
	    int subtype;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                if( Arg3 == NULL)
		{
		    fprintf( File_Output, "Index_List_SubType_Set: List SubType: ( 0:FIFO | 1:LIFO | 2:Sorted): ");
		    fgets( buf, BUF_LEN, File_Input);

		    Arg3 = buf;
		}

		subtype = atoi( Arg2);

                switch( subtype)
                {
                    case 0:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_FIFO;
                        break;
                    }

                    case 1:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_FILO;
                        break;
                    }

                    case 2:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_SORTED;
                        break;
                    }

                    default:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_UNKNOWN;
                        
                        LG_LOG_ERROR_1( "Invalid list subtype: (%d)", subtype);
                        break;
                    }
                }

		if( index_subtype != NDD_INDEX_SUBTYPE_UNKNOWN)
		{
		    LG_LOG_INFO_2( "Index_List_SubType_Set: Setting List SubType to: (%d) [%s]", index_subtype, ND_INDEX_SUBTYPE_VALUE_ASCII_GET( index_subtype));

		    t_start( t_exec);

		    for( i  = low; i <= high; i++)
		    {
			if( ND_INDEX_TYPE_LIST_IS( &( ( *DS_Ptr_Ptr)->ND_Root), i))
			{
			    ( *DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Type = ( (*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Type & NDD_INDEX_SUBTYPE_RMSK) | index_subtype;
			}
			else
			{
			    LG_LOG_ERROR_1( "Index: (%d) is not a list", i);
			}
		    }

		    t_stop( t_exec);

		    Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
		}
	    }

	    break;
        }

        case INDEX_TREE_SUBTYPE_SET:
        {
	    int subtype;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
		if( Arg3 == NULL)
		{
		    fprintf( File_Output, "Index_Tree_SubType_Set: Tree SubType (0:UnBalanced | 1:Balanced): ");
		    fgets( buf, BUF_LEN, stdin);

		    Arg3 = buf;
		}

		subtype = atoi( Arg3);

                switch( subtype)
                {
                    case 0:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_UNBALANCED;
                        break;
                    }

                    case 1:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_BALANCED;
                        break;
                    }

                    default:
                    {
			index_subtype = NDD_INDEX_SUBTYPE_UNKNOWN;
                        
                        LG_LOG_ERROR_1( "Invalid tree subtype: (%d)", subtype);
                        break;
                    }
		}

		if( index_subtype != NDD_INDEX_SUBTYPE_UNKNOWN)
		{
 
		    t_start( t_exec);

		    for( i  = low; i <= high; i++)
		    {
			if( ND_INDEX_TYPE_TREE_IS( &( ( *DS_Ptr_Ptr)->ND_Root), i))
			{
			    (*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Type = ( (*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Type & NDD_INDEX_SUBTYPE_RMSK) | index_subtype;
			}
			else
			{
			    LG_LOG_ERROR_1( "Index: (%d) is not a tree", i);
			}
		    }

		    t_stop( t_exec);

		    Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
		}
	    }

	    break;
        }

        case INDEX_REORG:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
		t_start( t_exec);

		for( i  = low; i <= high; i++)
		{
		    LG_LOG_INFO_1( "Index_Reorg: Reorganizing index (%d)...", i);

		    if( ( status = DS_Index_Reorg( *DS_Ptr_Ptr, (NDT_Index_Id)i)) != DSS_OK)
                    {
                        LG_LOG_ERROR_2( "Unable to reorganise index: (%d), status: (%d)", i, status);

                        break;
                    }
		}

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

	    break;
        }

        case INDEX_LIST_TO_TREE:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    LG_LOG_INFO_1( "Index_List_To_Tree: Converting Index (%d)...", i);

		    if( ( status = DS_Index_Convert( *DS_Ptr_Ptr, (NDT_Index_Id)i, DBD_IDX_TYPE_BALANCED_TREE)) != DSS_OK)
                    {
                        LG_LOG_ERROR_2( "Unable to convert index: (%d), status: (%d)", i, status);

                        break;
                    }
                }

                t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_TREE_TO_LIST:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    LG_LOG_INFO_1( "Index_Tree_To_List: Converting Index (%d)...", i);

		    if( ( status = DS_Index_Convert( *DS_Ptr_Ptr, (NDT_Index_Id)i, DBD_IDX_TYPE_SORTED_LIST)) != DSS_OK)
                    {
                        LG_LOG_ERROR_2( "Unable to convert index: (%d), status: (%d)", i, status);

                        break;
                    }
                }

                t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_INFO_PRINT:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                LG_LOG_INFO_2( "Index_Info_Print: Printing index from: (%d)   to: (%d)...", low, high);

                for( i  = low; i <= high; i++)
      	        {
		    DS_Index_Info_Print( File_Output, *DS_Ptr_Ptr, (NDT_Index_Id)i, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
                }
	    }

            break;
        }

        case INDEX_VALUE_PRINT:
        {
            LG_LOG_INFO_0( "DS_Value_Print:");

            DS_DataStruct_Value_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
            break;
        }

        case INDEX_VALUE_BREAK:
        {
	    int        position;
	    NDT_Node  *node_ptr;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
		if( Arg3 == NULL)
		{
		    fprintf( File_Output, "Index_Value_Break: Value position (0:Head | 1:Tail | 2:Random): ");
		    fgets( buf, BUF_LEN, stdin);

		    Arg3 = buf;
		}

		position = atoi( Arg3);

                LG_LOG_INFO_3( "Index_Value_Break: Breaking: (%s) values from index: (%d)   to: (%d)...",
                               ( position == 0 ) ? "Head" : ( ( position == 1) ? "Tail" : "Random"),
                               low, high);

                t_start( t_exec);

//                fprintf( File_Output, "Index_Value_Break: Breaking value of nodes: ");
//                fflush( File_Output);

                for( i  = low; i <= high; i++)
      	        {
		    switch( position)
		    {
			case 0:
			{
			    node_ptr  =(*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Head;
			    break;
			}

			case 1:
			{
			    node_ptr=(*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Tail;
			    break;
			}

			case 2:
			{
			    j = (int)( (double)( (*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Node_Number) * rand() / ( RAND_MAX + 1.0));

			    for( node_ptr = (*DS_Ptr_Ptr)->ND_Root.Index_Tab[i].Head; j > 0; j--)
			    {
				node_ptr = node_ptr->Right;
			    }

			    break;
			}
		    }

                    LG_LOG_INFO_1( "Index_Value_Break: Breaking value of node: (%p)", node_ptr);

		    node_ptr->Value = (void  *)-1;
                }

                t_stop (t_exec);

//		fprintf( File_Output, "\n");
//		fflush( File_Output);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }
/*
        case INDEX_NODE_BREAK:
        {

            break;
        }
*/
        case INDEX_CHECK:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, Arg2, File_Input, Choice, "Index");

            if( low != -1)
            {
                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    LG_LOG_INFO_1( "Index_Check: Checking Index (%d)...", i);
                    LG_LOG_INFO_0( "Index_Check: ");

		    nb_corrected = nb_detected = 0;
		    DS_Index_Check( *DS_Ptr_Ptr, (NDT_Index_Id)i, &nb_detected, &nb_corrected, File_Output);
                }

                t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case BATCH_RUN:
        {
            FILE  *file_input;


            if( Arg1 == NULL)
            {
                fprintf( File_Output, "Batch_Run: Batch file name ? ");

                fgets( buf, BUF_LEN, stdin);
                buf[ strlen( buf) - 1] = '\0';
                Arg1 = buf;
            }

            file_input = fopen( Arg1, "r");

            if( file_input == NULL)
            {
                LG_LOG_ERROR_1( "Batch_Run: Can't open file (%s)!", Arg1);
            }
            else
            {
                LG_LOG_INFO_0( "--------------------------------------------------------------------------------");
                LG_LOG_INFO_1( "Batch_Run: Starting execution (%s)...", Arg1);
                
                Batch_Run( DS_Ptr_Ptr, File_Output, file_input, 0);
                
                LG_LOG_INFO_1( "Batch_Run: Ending execution (%s)...", Arg1);

		fclose( file_input);
            }

            break;
        }

        default:
        {
            fprintf( File_Output, "\nUndefined command (%d) !\n", Choice);
        }
    }
}





/*----------------------------------------------------------------------------*/
/* Batch_Run                                                                  */
/*----------------------------------------------------------------------------*/

void  Batch_Run( DST_Root  **DS_Ptr_Ptr, FILE  *File_Output, FILE  *File_Input, short  Interactive_Flag)
{
    int    choice;
    char  *arg1, *arg2, *arg3;


    do
    {
        if( Interactive_Flag)
        {
            Menu_Print( File_Output, *DS_Ptr_Ptr);
        }

        Command_Get( &choice, &arg1, &arg2, &arg3, File_Output, File_Input, Interactive_Flag);

        if( ( choice != QUIT) && ( choice != -1))
        {
            Command_Exec( DS_Ptr_Ptr, File_Output, choice, arg1, arg2, arg3, File_Input);
        }

	if( arg1 != NULL) free( arg1);
	if( arg2 != NULL) free( arg2);
	if( arg3 != NULL) free( arg3);
    }
    while( choice != QUIT);
}





/*---------------------------------------------------------------------------------*/
/* main                                                                            */
/*---------------------------------------------------------------------------------*/

int  main( int  argc, char  **argv)
{
    int          rc = 0;
    LGT_Status   lg_status;
    DST_Root    *ds_ptr = NULL;


    if( ( lg_status = LG_Library_Open( LGD_LOG_WRITER_DEFAULT, true)) != LGS_OK)
    {
        fprintf( stderr, "Can't open LibLog library: (%d)\n", lg_status);
        return( -1);
    }

    LG_LOG_INFO_0( "Start DSBench");

    
    /* Init Random numbers... */
    t_start( t_exec);
    t_stop(  t_exec);
    srand( seed_get( t_exec));


    /* Args Parsing */

    if( argc >= 2)
    {
        if( !strcmp( argv[1], "--help"))
        {
            fprintf( stderr, USAGE, argv[0]);
            rc = 1;
        }
        else
        {
            if( !strcmp( argv[1], "--batch_run"))
            {
                /* Batch Mode */

                Command_Exec( &ds_ptr, stdout, BATCH_RUN, argv[2], NULL, NULL, stdin);
                rc = 0;
            
            }
            else
            {
                fprintf( stderr, USAGE, argv[0]);
                rc = -1;
            }
        }
    }
    else
    {
        /* Interactive Mode */
        
        Batch_Run( &ds_ptr, stdout, stdin, 1);
        rc = 0;
    }

    
    LG_LOG_INFO_0( "End DSBench");

    if( ( lg_status = LG_Library_Close( true)) != LGS_OK)
    {
        fprintf( stderr, "Can't close LibLog library: (%d)\n", lg_status);
        rc = -1;
    }

    return( rc);
}