945 lines
24 KiB
C
945 lines
24 KiB
C
/*
|
|
* build: gcc -o eet_data_file_descriptor_02 eet-data-file_descriptor_02.c `pkg-config --cflags --libs eet eina`
|
|
*/
|
|
|
|
#include <Eina.h>
|
|
#include <Eet.h>
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
typedef enum _Example_Data_Type Example_Data_Type;
|
|
typedef struct _Example_Variant_Type Example_Variant_Type;
|
|
typedef struct _Example_Variant Example_Variant;
|
|
typedef struct _Example_Union Example_Union;
|
|
typedef struct _Example_Struct1 Example_Struct1;
|
|
typedef struct _Example_Struct2 Example_Struct2;
|
|
typedef struct _Example_Struct3 Example_Struct3;
|
|
typedef struct _Example_Lists Example_Lists;
|
|
|
|
enum _Example_Data_Type
|
|
{
|
|
EET_UNKNOWN = 0,
|
|
EET_STRUCT1,
|
|
EET_STRUCT2,
|
|
EET_STRUCT3
|
|
};
|
|
|
|
struct
|
|
{
|
|
Example_Data_Type u;
|
|
const char *name;
|
|
} eet_mapping[] = {
|
|
{ EET_STRUCT1, "ST1" },
|
|
{ EET_STRUCT2, "ST2" },
|
|
{ EET_STRUCT3, "ST3" },
|
|
{ EET_UNKNOWN, NULL }
|
|
};
|
|
|
|
struct _Example_Struct1
|
|
{
|
|
double val1;
|
|
int stuff;
|
|
const char *s1;
|
|
};
|
|
|
|
struct _Example_Struct2
|
|
{
|
|
Eina_Bool b1;
|
|
unsigned long long v1;
|
|
};
|
|
|
|
struct _Example_Struct3
|
|
{
|
|
int body;
|
|
};
|
|
|
|
struct _Example_Union
|
|
{
|
|
Example_Data_Type type;
|
|
|
|
union {
|
|
Example_Struct1 st1;
|
|
Example_Struct2 st2;
|
|
Example_Struct3 st3;
|
|
} u;
|
|
};
|
|
|
|
struct _Example_Variant_Type
|
|
{
|
|
const char *type;
|
|
Eina_Bool unknow : 1;
|
|
};
|
|
|
|
struct _Example_Variant
|
|
{
|
|
Example_Variant_Type t;
|
|
|
|
void *data; /* differently than the union type, we
|
|
* don't need to pre-allocate the memory
|
|
* for the field*/
|
|
};
|
|
|
|
struct _Example_Lists
|
|
{
|
|
Eina_List *union_list;
|
|
Eina_List *variant_list;
|
|
};
|
|
|
|
static void
|
|
_st1_set(Example_Struct1 *st1,
|
|
double v1,
|
|
int v2,
|
|
const char *v3)
|
|
{
|
|
st1->val1 = v1;
|
|
st1->stuff = v2;
|
|
st1->s1 = v3;
|
|
} /* _st1_set */
|
|
|
|
static void
|
|
_st2_set(Example_Struct2 *st2,
|
|
Eina_Bool v1,
|
|
unsigned long long v2)
|
|
{
|
|
st2->b1 = v1;
|
|
st2->v1 = v2;
|
|
} /* _st2_set */
|
|
|
|
static void
|
|
_st3_set(Example_Struct3 *st3,
|
|
int v1)
|
|
{
|
|
st3->body = v1;
|
|
} /* _st3_set */
|
|
|
|
static const char *
|
|
/* union
|
|
type_get() */
|
|
_union_type_get(const void *data,
|
|
Eina_Bool *unknow)
|
|
{
|
|
const Example_Data_Type *u = data;
|
|
int i;
|
|
|
|
if (unknow)
|
|
*unknow = EINA_FALSE;
|
|
|
|
for (i = 0; eet_mapping[i].name != NULL; ++i)
|
|
if (*u == eet_mapping[i].u)
|
|
return eet_mapping[i].name;
|
|
|
|
if (unknow)
|
|
*unknow = EINA_TRUE;
|
|
|
|
return NULL;
|
|
} /* _union_type_get */
|
|
|
|
static Eina_Bool
|
|
_union_type_set(const char *type,
|
|
void *data,
|
|
Eina_Bool unknow)
|
|
{
|
|
Example_Data_Type *u = data;
|
|
int i;
|
|
|
|
if (unknow)
|
|
return EINA_FALSE;
|
|
|
|
for (i = 0; eet_mapping[i].name != NULL; ++i)
|
|
if (strcmp(eet_mapping[i].name, type) == 0)
|
|
{
|
|
*u = eet_mapping[i].u;
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
} /* _union_type_set */
|
|
|
|
static const char *
|
|
_variant_type_get(const void *data,
|
|
Eina_Bool *unknow)
|
|
{
|
|
const Example_Variant_Type *type = data;
|
|
int i;
|
|
|
|
if (unknow)
|
|
*unknow = type->unknow;
|
|
|
|
for (i = 0; eet_mapping[i].name != NULL; ++i)
|
|
if (strcmp(type->type, eet_mapping[i].name) == 0)
|
|
return eet_mapping[i].name;
|
|
|
|
if (unknow)
|
|
*unknow = EINA_FALSE;
|
|
|
|
return type->type;
|
|
} /* _variant_type_get */
|
|
|
|
static Eina_Bool
|
|
_variant_type_set(const char *type,
|
|
void *data,
|
|
Eina_Bool unknow)
|
|
{
|
|
Example_Variant_Type *vt = data;
|
|
|
|
vt->type = type;
|
|
vt->unknow = unknow;
|
|
return EINA_TRUE;
|
|
} /* _variant_type_set */
|
|
|
|
static Eet_Data_Descriptor *
|
|
_st1_dd(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
Eet_Data_Descriptor *res;
|
|
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Struct1);
|
|
res = eet_data_descriptor_file_new(&eddc);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(
|
|
res, Example_Struct1, "val1", val1, EET_T_DOUBLE);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(
|
|
res, Example_Struct1, "stuff", stuff, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(
|
|
res, Example_Struct1, "s1", s1, EET_T_STRING);
|
|
|
|
return res;
|
|
} /* _st1_dd */
|
|
|
|
static Eet_Data_Descriptor *
|
|
_st2_dd(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
Eet_Data_Descriptor *res;
|
|
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Struct2);
|
|
res = eet_data_descriptor_file_new(&eddc);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(
|
|
res, Example_Struct2, "b1", b1, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(
|
|
res, Example_Struct2, "v1", v1, EET_T_ULONG_LONG);
|
|
|
|
return res;
|
|
} /* _st2_dd */
|
|
|
|
static Eet_Data_Descriptor *
|
|
_st3_dd(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
Eet_Data_Descriptor *res;
|
|
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Struct3);
|
|
res = eet_data_descriptor_file_new(&eddc);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(
|
|
res, Example_Struct3, "body", body, EET_T_INT);
|
|
|
|
return res;
|
|
} /* _st3_dd */
|
|
|
|
/* string that represents the entry in the eet file. you might like to
|
|
* have different profiles or so in the same file, this is possible
|
|
* with different strings
|
|
*/
|
|
static const char CACHE_FILE_ENTRY[] = "cache";
|
|
|
|
/* keep the descriptor static global, so it can be shared by different
|
|
* functions (load/save) of this and only this file.
|
|
*/
|
|
static Eet_Data_Descriptor *_lists_descriptor;
|
|
static Eet_Data_Descriptor *_struct_1_descriptor;
|
|
static Eet_Data_Descriptor *_struct_2_descriptor;
|
|
static Eet_Data_Descriptor *_struct_3_descriptor;
|
|
static Eet_Data_Descriptor *_union_descriptor;
|
|
static Eet_Data_Descriptor *_variant_descriptor;
|
|
static Eet_Data_Descriptor *_union_unified_descriptor;
|
|
static Eet_Data_Descriptor *_variant_unified_descriptor;
|
|
|
|
/* keep file handle alive, so mmap()ed strings are all alive as
|
|
* well */
|
|
static Eet_File *_cache_file = NULL;
|
|
static Eet_Dictionary *_cache_dict = NULL;
|
|
|
|
static void
|
|
/* declaring types */
|
|
_data_descriptors_init(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Lists);
|
|
_lists_descriptor = eet_data_descriptor_file_new(&eddc);
|
|
|
|
_struct_1_descriptor = _st1_dd();
|
|
_struct_2_descriptor = _st2_dd();
|
|
_struct_3_descriptor = _st3_dd();
|
|
|
|
/* for union */
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Union);
|
|
_union_descriptor = eet_data_descriptor_file_new(&eddc);
|
|
|
|
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
|
|
eddc.func.type_get = _union_type_get;
|
|
eddc.func.type_set = _union_type_set;
|
|
_union_unified_descriptor = eet_data_descriptor_file_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(
|
|
_union_unified_descriptor, "ST1", _struct_1_descriptor);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(
|
|
_union_unified_descriptor, "ST2", _struct_2_descriptor);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(
|
|
_union_unified_descriptor, "ST3", _struct_3_descriptor);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_UNION(
|
|
_union_descriptor, Example_Union, "u", u, type,
|
|
_union_unified_descriptor);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(
|
|
_lists_descriptor, Example_Lists, "union_list", union_list,
|
|
_union_descriptor);
|
|
|
|
/* for variant */
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Variant);
|
|
_variant_descriptor = eet_data_descriptor_file_new(&eddc);
|
|
|
|
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
|
|
eddc.func.type_get = _variant_type_get;
|
|
eddc.func.type_set = _variant_type_set;
|
|
_variant_unified_descriptor = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(
|
|
_variant_unified_descriptor, "ST1", _struct_1_descriptor);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(
|
|
_variant_unified_descriptor, "ST2", _struct_2_descriptor);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(
|
|
_variant_unified_descriptor, "ST3", _struct_3_descriptor);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_VARIANT(
|
|
_variant_descriptor, Example_Variant, "data", data, t,
|
|
_variant_unified_descriptor);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(
|
|
_lists_descriptor, Example_Lists, "variant_list", variant_list,
|
|
_variant_descriptor);
|
|
} /* _data_descriptors_init */
|
|
|
|
static void
|
|
_data_descriptors_shutdown(void)
|
|
{
|
|
eet_data_descriptor_free(_lists_descriptor);
|
|
eet_data_descriptor_free(_struct_1_descriptor);
|
|
eet_data_descriptor_free(_struct_2_descriptor);
|
|
eet_data_descriptor_free(_struct_3_descriptor);
|
|
eet_data_descriptor_free(_union_descriptor);
|
|
eet_data_descriptor_free(_variant_descriptor);
|
|
eet_data_descriptor_free(_union_unified_descriptor);
|
|
eet_data_descriptor_free(_variant_unified_descriptor);
|
|
} /* _data_descriptors_shutdown */
|
|
|
|
/* need to check if the pointer came from mmap()ed area in
|
|
* eet_dictionary or it was allocated with eina_stringshare_add()
|
|
*/
|
|
static void
|
|
_string_free(const char *str)
|
|
{
|
|
if (!str)
|
|
return;
|
|
|
|
if ((_cache_dict) && (eet_dictionary_string_check(_cache_dict, str)))
|
|
return;
|
|
|
|
eina_stringshare_del(str);
|
|
} /* _string_free */
|
|
|
|
static Example_Union *
|
|
_union_1_new(const char *v1,
|
|
const char *v2,
|
|
const char *v3)
|
|
{
|
|
Example_Union *un = calloc(1, sizeof(Example_Union));
|
|
if (!un)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not allocate an Example_Union struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
un->type = EET_STRUCT1;
|
|
_st1_set(&(un->u.st1), atof(v1), atoi(v2), eina_stringshare_add(v3));
|
|
|
|
return un;
|
|
}
|
|
|
|
static Example_Union *
|
|
_union_2_new(const char *v1,
|
|
const char *v2)
|
|
{
|
|
Example_Union *un = calloc(1, sizeof(Example_Union));
|
|
if (!un)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not allocate an Example_Union struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
un->type = EET_STRUCT2;
|
|
_st2_set(&(un->u.st2), atoi(v1), atoi(v2));
|
|
|
|
return un;
|
|
}
|
|
|
|
static Example_Union *
|
|
_union_3_new(const char *v1)
|
|
{
|
|
Example_Union *un = calloc(1, sizeof(Example_Union));
|
|
if (!un)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not allocate an Example_Union struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
un->type = EET_STRUCT3;
|
|
_st3_set(&(un->u.st3), atoi(v1));
|
|
|
|
return un;
|
|
}
|
|
|
|
static Example_Variant *
|
|
_variant_1_new(const char *v1,
|
|
const char *v2,
|
|
const char *v3)
|
|
{
|
|
Example_Struct1 *st1;
|
|
Example_Variant *va = calloc(1, sizeof(Example_Variant));
|
|
if (!va)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not allocate an Example_Variant struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
va = calloc(1, sizeof (Example_Variant));
|
|
va->t.type = eet_mapping[0].name;
|
|
st1 = calloc(1, sizeof (Example_Struct1));
|
|
_st1_set(st1, atof(v1), atoi(v2), eina_stringshare_add(v3));
|
|
va->data = st1;
|
|
|
|
return va;
|
|
}
|
|
|
|
static Example_Variant *
|
|
_variant_2_new(const char *v1,
|
|
const char *v2)
|
|
{
|
|
printf("varinant 2 new\n");
|
|
|
|
Example_Struct2 *st2;
|
|
Example_Variant *va = calloc(1, sizeof(Example_Variant));
|
|
if (!va)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not allocate an Example_Variant struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
va = calloc(1, sizeof (Example_Variant));
|
|
|
|
va->t.type = eet_mapping[1].name;
|
|
|
|
printf("type gets %s\n", va->t.type);
|
|
|
|
st2 = calloc(1, sizeof (Example_Struct2));
|
|
_st2_set(st2, atoi(v1), atoi(v2));
|
|
va->data = st2;
|
|
|
|
return va;
|
|
}
|
|
|
|
static Example_Variant *
|
|
_variant_3_new(const char *v1)
|
|
{
|
|
Example_Struct3 *st3;
|
|
Example_Variant *va = calloc(1, sizeof(Example_Variant));
|
|
if (!va)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not allocate an Example_Variant struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
va = calloc(1, sizeof (Example_Variant));
|
|
va->t.type = eet_mapping[2].name;
|
|
st3 = calloc(1, sizeof (Example_Struct3));
|
|
_st3_set(st3, atoi(v1));
|
|
va->data = st3;
|
|
|
|
return va;
|
|
}
|
|
|
|
static Example_Lists *
|
|
_data_new(void)
|
|
{
|
|
Example_Lists *example_lists = calloc(1, sizeof(Example_Lists));
|
|
if (!example_lists)
|
|
{
|
|
fprintf(stderr, "ERROR: could not allocate a Example_Lists struct.\n");
|
|
return NULL;
|
|
}
|
|
|
|
return example_lists;
|
|
} /* _data_new */
|
|
|
|
static void
|
|
_union_free(Example_Union *un)
|
|
{
|
|
if (un->type == EET_STRUCT1)
|
|
{
|
|
Example_Struct1 *st1 = &(un->u.st1);
|
|
_string_free(st1->s1);
|
|
}
|
|
|
|
free(un);
|
|
}
|
|
|
|
static void
|
|
_variant_free(Example_Variant *va)
|
|
{
|
|
if (!strcmp(va->t.type, eet_mapping[0].name))
|
|
{
|
|
Example_Struct1 *st1 = va->data;
|
|
_string_free(st1->s1);
|
|
}
|
|
|
|
free(va->data);
|
|
free(va);
|
|
}
|
|
|
|
static void
|
|
_data_free(Example_Lists *cache)
|
|
{
|
|
Example_Union *un;
|
|
Example_Variant *va;
|
|
|
|
EINA_LIST_FREE(cache->union_list, un)
|
|
_union_free(un);
|
|
|
|
EINA_LIST_FREE(cache->variant_list, va)
|
|
_variant_free(va);
|
|
|
|
free(cache);
|
|
} /* _data_free */
|
|
|
|
static Example_Lists *
|
|
_data_load(const char *filename)
|
|
{
|
|
Example_Lists *data;
|
|
Eet_File *ef = eet_open(filename, EET_FILE_MODE_READ);
|
|
if (!ef)
|
|
{
|
|
fprintf(stderr, "ERROR: could not open '%s' for read\n", filename);
|
|
return NULL;
|
|
}
|
|
|
|
data = eet_data_read(ef, _lists_descriptor, CACHE_FILE_ENTRY);
|
|
if (!data)
|
|
{
|
|
eet_close(ef);
|
|
return NULL;
|
|
}
|
|
|
|
if (_cache_file)
|
|
eet_close(_cache_file);
|
|
|
|
_cache_file = ef;
|
|
_cache_dict = eet_dictionary_get(ef);
|
|
|
|
return data;
|
|
} /* _data_load */
|
|
|
|
static Eina_Bool
|
|
_data_save(const Example_Lists *cache,
|
|
const char *filename)
|
|
{
|
|
char tmp[PATH_MAX];
|
|
Eet_File *ef;
|
|
Eina_Bool ret;
|
|
unsigned int i, len;
|
|
struct stat st;
|
|
|
|
len = eina_strlcpy(tmp, filename, sizeof(tmp));
|
|
if (len + 12 >= (int)sizeof(tmp))
|
|
{
|
|
fprintf(stderr, "ERROR: file name is too big: %s\n", filename);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
i = 0;
|
|
do
|
|
{
|
|
snprintf(tmp + len, 12, ".%u", i);
|
|
i++;
|
|
}
|
|
while (stat(tmp, &st) == 0);
|
|
|
|
ef = eet_open(tmp, EET_FILE_MODE_WRITE);
|
|
if (!ef)
|
|
{
|
|
fprintf(stderr, "ERROR: could not open '%s' for write\n", tmp);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
ret = eet_data_write
|
|
(ef, _lists_descriptor, CACHE_FILE_ENTRY, cache, EINA_TRUE);
|
|
|
|
eet_close(ef);
|
|
|
|
if (ret)
|
|
{
|
|
unlink(filename);
|
|
rename(tmp, filename);
|
|
}
|
|
|
|
return ret;
|
|
} /* _data_save */
|
|
|
|
static void
|
|
_print_union(const Example_Union *un)
|
|
{
|
|
printf("\t | type: %s'\n", eet_mapping[un->type - 1].name);
|
|
|
|
switch (un->type)
|
|
{
|
|
case EET_STRUCT1:
|
|
printf("\t\t val1: %f\n", un->u.st1.val1);
|
|
printf("\t\t stuff: %d\n", un->u.st1.stuff);
|
|
printf("\t\t s1: %s\n", un->u.st1.s1);
|
|
break;
|
|
|
|
case EET_STRUCT2:
|
|
printf("\t\t val1: %i\n", un->u.st2.b1);
|
|
printf("\t\t stuff: %lli\n", un->u.st2.v1);
|
|
break;
|
|
|
|
case EET_STRUCT3:
|
|
printf("\t\t val1: %i\n", un->u.st3.body);
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void
|
|
_print_variant(const Example_Variant *va)
|
|
{
|
|
printf("\t | type: %s'\n", va->t.type);
|
|
|
|
switch (va->t.type[2])
|
|
{
|
|
case '1':
|
|
{
|
|
Example_Struct1 *st1 = va->data;
|
|
|
|
printf("\t\t val1: %f\n", st1->val1);
|
|
printf("\t\t stuff: %d\n", st1->stuff);
|
|
printf("\t\t s1: %s\n", st1->s1);
|
|
}
|
|
break;
|
|
|
|
case '2':
|
|
{
|
|
Example_Struct2 *st2 = va->data;
|
|
|
|
printf("\t\t val1: %i\n", st2->b1);
|
|
printf("\t\t stuff: %lli\n", st2->v1);
|
|
}
|
|
break;
|
|
|
|
case '3':
|
|
{
|
|
Example_Struct3 *st3 = va->data;
|
|
|
|
printf("\t\t val1: %i\n", st3->body);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
int
|
|
main(int argc,
|
|
char *argv[])
|
|
{
|
|
Example_Lists *data_lists;
|
|
int ret = 0;
|
|
|
|
if (argc < 3)
|
|
{
|
|
fprintf(stderr,
|
|
"Usage:\n\t%s <input> <output> [action action-params]\n\n"
|
|
"where actions and their parameters are:\n"
|
|
"\tunion <type> [fields]\n"
|
|
"\tvariant <type> [fields]\n"
|
|
"\n",
|
|
argv[0]);
|
|
return -1;
|
|
}
|
|
|
|
eina_init();
|
|
eet_init();
|
|
_data_descriptors_init();
|
|
|
|
data_lists = _data_load(argv[1]);
|
|
if (!data_lists)
|
|
{
|
|
printf("Creating new data lists.\n");
|
|
data_lists = _data_new();
|
|
if (!data_lists)
|
|
{
|
|
ret = -2;
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
if (argc > 3)
|
|
{
|
|
if (strcmp(argv[3], "union") == 0)
|
|
{
|
|
if (argc > 4)
|
|
{
|
|
int type = atoi(argv[4]);
|
|
Example_Union *un;
|
|
|
|
if (type < EET_STRUCT1 || type > EET_STRUCT3)
|
|
{
|
|
fprintf(stderr,
|
|
"ERROR: invalid type parameter (%s).\n",
|
|
argv[4]);
|
|
goto cont;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case 1:
|
|
if (argc != 8)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: wrong number of parameters"
|
|
" (%d).\n", argc);
|
|
goto cont;
|
|
}
|
|
|
|
un = _union_1_new(
|
|
argv[5], argv[6], argv[7]);
|
|
if (!un)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not create the "
|
|
"requested union.\n");
|
|
goto cont;
|
|
}
|
|
data_lists->union_list =
|
|
eina_list_append(data_lists->union_list, un);
|
|
break;
|
|
|
|
case 2:
|
|
if (argc != 7)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: wrong number of parameters"
|
|
" (%d).\n", argc);
|
|
goto cont;
|
|
}
|
|
|
|
un = _union_2_new(argv[5], argv[6]);
|
|
if (!un)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not create the "
|
|
"requested union.\n");
|
|
goto cont;
|
|
}
|
|
data_lists->union_list =
|
|
eina_list_append(data_lists->union_list, un);
|
|
break;
|
|
|
|
case 3:
|
|
if (argc != 6)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: wrong number of parameters"
|
|
" (%d).\n", argc);
|
|
goto cont;
|
|
}
|
|
|
|
un = _union_3_new(argv[5]);
|
|
if (!un)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not create the "
|
|
"requested union.\n");
|
|
goto cont;
|
|
}
|
|
data_lists->union_list =
|
|
eina_list_append(data_lists->union_list, un);
|
|
break;
|
|
|
|
default:
|
|
fprintf(
|
|
stderr, "ERROR: bad type of of struct passed\n");
|
|
goto cont;
|
|
}
|
|
}
|
|
else
|
|
fprintf(stderr,
|
|
"ERROR: wrong number of parameters (%d).\n",
|
|
argc);
|
|
}
|
|
else if (strcmp(argv[3], "variant") == 0)
|
|
{
|
|
if (argc > 4)
|
|
{
|
|
int type = atoi(argv[4]);
|
|
Example_Variant *va;
|
|
|
|
if (type < EET_STRUCT1 || type > EET_STRUCT3)
|
|
{
|
|
fprintf(stderr,
|
|
"ERROR: invalid type parameter (%s).\n",
|
|
argv[4]);
|
|
goto cont;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case 1:
|
|
if (argc != 8)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: wrong number of parameters"
|
|
" (%d).\n", argc);
|
|
goto cont;
|
|
}
|
|
|
|
va = _variant_1_new(
|
|
argv[5], argv[6], argv[7]);
|
|
if (!va)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not create the "
|
|
"requested variant.\n");
|
|
goto cont;
|
|
}
|
|
data_lists->variant_list =
|
|
eina_list_append(data_lists->variant_list, va);
|
|
break;
|
|
|
|
case 2:
|
|
if (argc != 7)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: wrong number of parameters"
|
|
" (%d).\n", argc);
|
|
goto cont;
|
|
}
|
|
|
|
va = _variant_2_new(argv[5], argv[6]);
|
|
if (!va)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not create the "
|
|
"requested variant.\n");
|
|
goto cont;
|
|
}
|
|
data_lists->variant_list =
|
|
eina_list_append(data_lists->variant_list, va);
|
|
break;
|
|
|
|
case 3:
|
|
if (argc != 6)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: wrong number of parameters"
|
|
" (%d).\n", argc);
|
|
goto cont;
|
|
}
|
|
|
|
va = _variant_3_new(argv[5]);
|
|
if (!va)
|
|
{
|
|
fprintf(
|
|
stderr, "ERROR: could not create the "
|
|
"requested variant.\n");
|
|
goto cont;
|
|
}
|
|
data_lists->variant_list =
|
|
eina_list_append(data_lists->variant_list, va);
|
|
break;
|
|
|
|
default:
|
|
fprintf(
|
|
stderr, "ERROR: bad type of of struct passed\n");
|
|
goto cont;
|
|
}
|
|
}
|
|
else
|
|
fprintf(stderr,
|
|
"ERROR: wrong number of parameters (%d).\n",
|
|
argc);
|
|
}
|
|
else
|
|
fprintf(stderr, "ERROR: unknown action '%s'\n", argv[3]);
|
|
}
|
|
|
|
cont:
|
|
printf("Cached data:\n");
|
|
|
|
printf("\tstats: unions=%u, variants=%u\n",
|
|
eina_list_count(data_lists->union_list),
|
|
eina_list_count(data_lists->variant_list));
|
|
|
|
if (eina_list_count(data_lists->union_list))
|
|
{
|
|
const Eina_List *l;
|
|
const Example_Union *un;
|
|
printf("\t * union list:\n");
|
|
|
|
EINA_LIST_FOREACH(data_lists->union_list, l, un)
|
|
{
|
|
_print_union(un);
|
|
}
|
|
}
|
|
|
|
if (eina_list_count(data_lists->variant_list))
|
|
{
|
|
const Eina_List *l;
|
|
const Example_Variant *un;
|
|
printf("\t * variant list:\n");
|
|
|
|
EINA_LIST_FOREACH(data_lists->variant_list, l, un)
|
|
{
|
|
_print_variant(un);
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
if (!_data_save(data_lists, argv[2]))
|
|
ret = -3;
|
|
|
|
_data_free(data_lists);
|
|
|
|
end:
|
|
if (_cache_file)
|
|
eet_close(_cache_file);
|
|
_data_descriptors_shutdown();
|
|
eet_shutdown();
|
|
eina_shutdown();
|
|
|
|
return ret;
|
|
} /* main */
|
|
|