libnode/demo/nddemo0.c

727 lines
21 KiB
C
Raw Normal View History

/*----------------------------------------------------------------------------*/
/* nddemo.c */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* This file is part of LibNode. */
/* */
/* LibNode 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. */
/* */
/* LibNode 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 LibNode. If not, see <https://www.gnu.org/licenses/>. */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Includes */
/*----------------------------------------------------------------------------*/
#include <stdio.h>
#include <errno.h>
#include <node.h>
#define DEMO_FILE_NAME "nddemo0.dat"
2004-08-24 00:48:37 +02:00
#define STRING_LEN ( short) 1024
#define STRING_SIZE ( short) ( STRING_LEN + 1)
#define VAL_LEN ( short) 64
#define VAL_SIZE ( short) ( VAL_LEN + 1)
#define INDEX_NB ( short) 4
2004-08-24 00:48:37 +02:00
#define NDD_CMD_INDEX0_PRINT ( NDT_Command) 64
#define NDD_CMD_INDEX1_PRINT ( NDT_Command) 65
#define NDD_CMD_INDEX2_PRINT ( NDT_Command) 66
#define NDD_CMD_INDEX3_PRINT ( NDT_Command) 67
typedef struct Demo_Value
{
2004-08-24 00:48:37 +02:00
char Val0[ VAL_SIZE];
char Val1[ VAL_SIZE];
char Val2[ VAL_SIZE];
char Val3[ VAL_SIZE];
} Demo_Value;
/*---------------------------------------------------------------------------------*/
/* Prototypes */
/*---------------------------------------------------------------------------------*/
NDT_Status Demo_DS_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
void DataStruct_Load( NDT_Root *, FILE *);
void DataStruct_Load( NDT_Root *, FILE *);
void Demo( char *, short);
int main( int, char **);
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
NDT_Status Demo_DS_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;
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";
*Version_Name_Ptr = "$Revision: 2.9 $ $Name: $ $Date: 2010/06/06 21:27:12 $ $Author: agibert $";
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, Demo_Value *);
Command_Name = "NDD_CMD_INDEX_GET";
switch(Cmd)
{
2004-08-24 00:48:37 +02:00
case NDD_CMD_INDEX0_PRINT:
{
*Reply_Index_Id_Ptr = 0;
*Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
break;
}
2004-08-24 00:48:37 +02:00
case NDD_CMD_INDEX1_PRINT:
{
*Reply_Index_Id_Ptr = 1;
*Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
break;
}
2004-08-24 00:48:37 +02:00
case NDD_CMD_INDEX2_PRINT:
{
*Reply_Index_Id_Ptr = 2;
*Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
break;
}
2004-08-24 00:48:37 +02:00
case NDD_CMD_INDEX3_PRINT:
{
*Reply_Index_Id_Ptr = 3;
*Reply_Command_Ptr = NDD_CMD_VALUE_PRINT;
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( Value_Ptr_Ptr, *Args_Ptr, Demo_Value **);
Command_Name = "NDD_CMD_VALUE_ALLOC";
if( ( *Value_Ptr_Ptr = (Demo_Value *)malloc( sizeof(Demo_Value))) == NULL)
{
return(NDS_ERRMEM);
}
else
{
(*Value_Ptr_Ptr)->Val0[0] = '\0';
(*Value_Ptr_Ptr)->Val1[0] = '\0';
(*Value_Ptr_Ptr)->Val2[0] = '\0';
(*Value_Ptr_Ptr)->Val3[0] = '\0';
return( NDS_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( Value_Ptr, *Args_Ptr, Demo_Value *);
Command_Name = "NDD_CMD_VALUE_FREE";
free( Value_Ptr);
return( NDS_OK);
}
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, Demo_Value *);
ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, Demo_Value *);
Command_Name = "NDD_CMD_VALUE_COMP";
switch( Index_Id)
{
case 0:
{
int rc;
rc = strcmp( Value1_Ptr->Val0, Value2_Ptr->Val0);
if( rc < 0)
{
2004-08-24 00:48:37 +02:00
return( NDS_LOWER);
}
else
{
if( rc > 0)
{
2004-08-24 00:48:37 +02:00
return( NDS_GREATER);
}
else
{
2004-08-24 00:48:37 +02:00
return( NDS_EQUAL);
}
}
}
case 1:
{
2004-08-24 00:48:37 +02:00
int val1 = atoi( Value1_Ptr->Val1);
int val2 = atoi( Value2_Ptr->Val1);
if( val1 < val2)
{
2004-08-24 00:48:37 +02:00
return( NDS_LOWER);
}
else
{
if( val1 > val2)
{
2004-08-24 00:48:37 +02:00
return( NDS_GREATER);
}
else
{
2004-08-24 00:48:37 +02:00
return( NDS_EQUAL);
}
}
}
case 2:
{
2004-08-24 00:48:37 +02:00
int val1 = strlen( Value1_Ptr->Val2);
int val2 = strlen( Value2_Ptr->Val2);
if( val1 < val2)
{
2004-08-24 00:48:37 +02:00
return( NDS_LOWER);
}
else
{
if( val1 > val2)
{
2004-08-24 00:48:37 +02:00
return( NDS_GREATER);
}
else
{
2004-08-24 00:48:37 +02:00
return( NDS_EQUAL);
}
}
}
default:
{
printf( "Unknown COMP idx (%d) !\n", 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";
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";
2004-08-24 00:48:37 +02:00
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);
*/
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);
Demo_Value *Value_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_VALUE_PRINT";
fprintf( Out, "Val0: (%s) Val1: (%s) Val2: (%s) Val3: (%s)\n",
Value_Ptr->Val0, Value_Ptr->Val1, Value_Ptr->Val2, Value_Ptr->Val3);
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);
*/
Command_Name = "NDD_CMD_INFO_PRINT";
return( NDS_OK);
}
default:
{
printf( "Demo_DS_Manager() called with an undefined command %d\n", Command);
2004-08-24 00:48:37 +02:00
return( NDS_ERRAPI);
}
}
printf( "Demo_DS_Manager() called with command %d (%s)\n", Command, Command_Name);
2004-08-24 00:48:37 +02:00
return( NDS_OK);
}
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
void DataStruct_Load( NDT_Root *ds_ptr, FILE *demo_file)
{
NDT_Status status;
char *str;
char input_string[STRING_SIZE];
char val0[VAL_SIZE], val1[VAL_SIZE], val2[VAL_SIZE], val3[VAL_SIZE];
Demo_Value *value_ptr;
while( !feof( demo_file))
{
str = fgets( input_string, STRING_SIZE, demo_file);
if( str != NULL)
{
if( strlen( input_string) >= STRING_LEN)
{
printf( "Input line too long ! Skipping ...");
while( !feof( demo_file) && strlen( input_string) >= STRING_LEN)
{
printf( ".");
str = fgets( input_string, STRING_SIZE, demo_file);
}
printf("\n");
}
else
{
if( input_string[0] != '#')
{
if( sscanf( input_string, "%s %s %s %s\n", val0, val1, val2, val3) != 4)
{
printf( "Input line scaning error... Skipping !\n");
}
else
{
printf( "Input line read: \t(%s)\t(%s)\t(%s)\t(%s)\n", val0, val1, val2, val3);
printf( "Allocate Vallue: ");
if( ( status = ND_Value_Alloc( (void **)&value_ptr, ds_ptr)) != NDS_OK)
{
printf( "ND_Value_Alloc() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
strcpy( value_ptr->Val0, val0);
strcpy( value_ptr->Val1, val1);
strcpy( value_ptr->Val2, val2);
strcpy( value_ptr->Val3, val3);
printf( "Add Vallue: ");
if( ( status = ND_DataStruct_Value_Add( ds_ptr, (void **)value_ptr)) != NDS_OK)
{
printf( "ND_Value_Add() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
}
}
}
}
}
}
}
}
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
void DataStruct_Dump( NDT_Root *ds_ptr)
{
NDT_Status status;
printf( "Print DataStructure Info:\n");
if( ( status = ND_DataStruct_Info_Print( stdout, ds_ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Info_Print() failed (%d) !\n", status);
}
printf( "\n");
printf( "Traverse DataStructure Index 0:\n");
2004-08-24 00:48:37 +02:00
if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX0_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
}
printf( "\n");
printf( "Traverse DataStructure Index 1:\n");
2004-08-24 00:48:37 +02:00
if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX1_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
}
printf( "\n");
printf( "Traverse DataStructure Index 2:\n");
2004-08-24 00:48:37 +02:00
if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX2_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
}
printf( "\n");
printf( "Traverse DataStructure Index 3:\n");
2004-08-24 00:48:37 +02:00
if( ( status = ND_DataStruct_Traverse( ds_ptr, NDD_CMD_INDEX3_PRINT, stdout, NDD_RECURSIVE_MODE_PARENT, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Traverse() failed (%d) !\n", status);
}
printf( "\n");
}
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
void Demo( char *Demo_File_Name, short Optimized_Mode)
{
NDT_Status status;
NDT_Root *demo_ds_ptr;
NDT_Index_Type index_type_initial_tab[INDEX_NB] =
{
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO),
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO),
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO),
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO)
};
NDT_Index_Type index_type_final_tab[INDEX_NB] =
{
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED),
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED),
(NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO)
};
NDT_Index_Type *index_type_ptr;
FILE *demo_file;
printf( "Open library: ");
if( ( status = ND_Library_Open( NDD_TRUE)) != NDS_OK)
{
printf( "ND_Library_Open() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
printf( "Create demo DataStructure: ");
if( Optimized_Mode)
{
index_type_ptr = index_type_initial_tab;
}
else
{
index_type_ptr = index_type_final_tab;
}
if( ( status = ND_DataStruct_Open( &demo_ds_ptr, "NDDemo0", ND_OPEN_FLAG_CREATE, INDEX_NB, index_type_ptr, "Demo_DS_Manager", Demo_DS_Manager, NULL, 0, NULL)) != NDS_OK)
{
printf( "ND_DataStruct_Open() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
printf( "Open demo datafile: ");
if( ( demo_file = fopen( Demo_File_Name, "r")) == NULL)
{
printf( "fopen() failed (%d/%s) !\n", errno, strerror(errno));
}
else
{
printf( "Ok !\n");
printf( "\n\n\nLaod Data File:\n\n");
DataStruct_Load( demo_ds_ptr, demo_file);
if( Optimized_Mode)
{
printf( "\n\n\nInitial Structure Dump:\n\n");
DataStruct_Dump( demo_ds_ptr);
printf( "Convert data structure: ");
if( ( status = ND_DataStruct_Convert( demo_ds_ptr, index_type_final_tab)) != NDS_OK)
{
printf( "ND_DataStruct_Convert() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
}
}
printf( "\n\n\nFinal Structure Dump:\n\n");
DataStruct_Dump( demo_ds_ptr);
printf( "Close demo datafile: ");
if( fclose( demo_file) != 0)
{
printf( "fclose() failed (%d/%s) !\n", errno, strerror(errno));
}
else
{
printf( "Ok !\n");
}
}
printf( "Close demo DataStructure: ");
if( ( status = ND_DataStruct_Close( demo_ds_ptr)) != NDS_OK)
{
printf( "ND_DataStruct_Close() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
}
}
printf( "Close library: ");
if( ( status = ND_Library_Close()) != NDS_OK)
{
printf( "ND_Library_Close() failed (%d) !\n", status);
}
else
{
printf( "Ok !\n");
}
}
}
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
int main( int argc, char **argv)
{
2003-01-17 09:06:57 +01:00
printf( "Non Optimized Demo\n------------------\n\n\n");
Demo( DEMO_FILE_NAME, 0);
2003-01-17 09:06:57 +01:00
printf( "\n\n\n\n\nOptimized Demo\n--------------\n\n\n");
Demo( DEMO_FILE_NAME, 1);
}