File descriptor data example, with Eet unions and variants

This is an example much like the one shown in Advanced use of Eet Data Descriptors.

The difference is that here we're attaining ourselves to two new data types to store in an Eet file – unions and variants. We don't try to come with data mapping to real world use cases, here. Instead, we're defining 3 different simple structures to be used throughout the example:

typedef struct _Example_Struct1 Example_Struct1;
typedef struct _Example_Struct2 Example_Struct2;
typedef struct _Example_Struct3 Example_Struct3;
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;
};

To identify, for both union and variant data cases, the type of each chunk of data, we're defining types to point to each of those structs:

typedef enum _Example_Data_Type Example_Data_Type;
enum _Example_Data_Type
{
EET_UNKNOWN = 0,
EET_STRUCT1,
EET_STRUCT2,
EET_STRUCT3
};

We have also a mapping from those types to name strings, to be used in the Eet unions and variants type_get() and type_set() type identifying callbacks:

struct
{
Example_Data_Type u;
const char *name;
} eet_mapping[] = {
{ EET_STRUCT1, "ST1" },
{ EET_STRUCT2, "ST2" },
{ EET_STRUCT3, "ST3" },
{ EET_UNKNOWN, NULL }
};

In this example, we have no fancy hash to store our data into profiles/accounts, but just two lists for union and variant data nodes:

typedef struct _Example_Lists Example_Lists;
struct _Example_Lists
{
Eina_List *union_list;
Eina_List *variant_list;
};

Let's begin with our unions, then, which look like:

typedef struct _Example_Union Example_Union;
struct _Example_Union
{
Example_Data_Type type;
union {
Example_Struct1 st1;
Example_Struct2 st2;
Example_Struct3 st3;
} u;
};

The first interesting part of the code is where we define our data descriptors for the main lists, the unions and all of structures upon which those two depend.

/* declaring types */
_data_descriptors_init(void)
{
_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 */
_union_descriptor = eet_data_descriptor_file_new(&eddc);
eddc.func.type_get = _union_type_get;
eddc.func.type_set = _union_type_set;
_union_unified_descriptor = eet_data_descriptor_file_new(&eddc);
_union_unified_descriptor, "ST1", _struct_1_descriptor);
_union_unified_descriptor, "ST2", _struct_2_descriptor);
_union_unified_descriptor, "ST3", _struct_3_descriptor);
_union_descriptor, Example_Union, "u", u, type,
_union_unified_descriptor);
_lists_descriptor, Example_Lists, "union_list", union_list,
_union_descriptor);
The code for descriptors on Example_Struct1, Example_Struct2 and Example_Struct3 is straightforward, a matter already covered on Advanced use of Eet Data Descriptors. What is new, here, are the two type matching functions for our unions. There, we must set the data pointer to its matching type, on _union_type_set and return the correct matching type, on _union_type_get:

With the EET_DATA_DESCRIPTOR_ADD_MAPPING calls, which follow, we make the the link between our type names and their respective structs. The code handling actual data is pretty much the same as in Advanced use of Eet Data Descriptors – one uses command line arguments to enter new data chunks (or just to visualize the contents of an Eet file), signalling if they are unions or variants. One must also pass the type of the data chuck to enter, with integers 1, 2 or

  1. Then, come the fields for each type:
    "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]);

Variants are very similar to unions, except that data chunks need not contain previously allocated space for each of the possible types of data going in them:

typedef struct _Example_Variant_Type Example_Variant_Type;
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*/
};

The code declaring the data descriptors and handling the data is very similar to the unions part, and is left for the reader to check for him/herself. The complete code of the example follows.

1 /*
2  * build: gcc -o eet_data_file_descriptor_02 eet-data-file_descriptor_02.c `pkg-config --cflags --libs eet eina`
3  */
4 
5 #include <Eina.h>
6 #include <Eet.h>
7 #include <stdio.h>
8 #include <limits.h>
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <unistd.h>
12 
13 typedef enum _Example_Data_Type Example_Data_Type;
14 typedef struct _Example_Variant_Type Example_Variant_Type;
15 typedef struct _Example_Variant Example_Variant;
16 typedef struct _Example_Union Example_Union;
17 typedef struct _Example_Struct1 Example_Struct1;
18 typedef struct _Example_Struct2 Example_Struct2;
19 typedef struct _Example_Struct3 Example_Struct3;
20 typedef struct _Example_Lists Example_Lists;
21 
22 enum _Example_Data_Type
23 {
24  EET_UNKNOWN = 0,
25  EET_STRUCT1,
26  EET_STRUCT2,
27  EET_STRUCT3
28 };
29 
30 struct
31 {
32  Example_Data_Type u;
33  const char *name;
34 } eet_mapping[] = {
35  { EET_STRUCT1, "ST1" },
36  { EET_STRUCT2, "ST2" },
37  { EET_STRUCT3, "ST3" },
38  { EET_UNKNOWN, NULL }
39 };
40 
41 struct _Example_Struct1
42 {
43  double val1;
44  int stuff;
45  const char *s1;
46 };
47 
48 struct _Example_Struct2
49 {
50  Eina_Bool b1;
51  unsigned long long v1;
52 };
53 
54 struct _Example_Struct3
55 {
56  int body;
57 };
58 
59 struct _Example_Union
60 {
61  Example_Data_Type type;
62 
63  union {
64  Example_Struct1 st1;
65  Example_Struct2 st2;
66  Example_Struct3 st3;
67  } u;
68 };
69 
70 struct _Example_Variant_Type
71 {
72  const char *type;
73  Eina_Bool unknow : 1;
74 };
75 
76 struct _Example_Variant
77 {
78  Example_Variant_Type t;
79 
80  void *data; /* differently than the union type, we
81  * don't need to pre-allocate the memory
82  * for the field*/
83 };
84 
85 struct _Example_Lists
86 {
87  Eina_List *union_list;
88  Eina_List *variant_list;
89 };
90 
91 static void
92 _st1_set(Example_Struct1 *st1,
93  double v1,
94  int v2,
95  const char *v3)
96 {
97  st1->val1 = v1;
98  st1->stuff = v2;
99  st1->s1 = v3;
100 } /* _st1_set */
101 
102 static void
103 _st2_set(Example_Struct2 *st2,
104  Eina_Bool v1,
105  unsigned long long v2)
106 {
107  st2->b1 = v1;
108  st2->v1 = v2;
109 } /* _st2_set */
110 
111 static void
112 _st3_set(Example_Struct3 *st3,
113  int v1)
114 {
115  st3->body = v1;
116 } /* _st3_set */
117 
118 static const char *
119 /* union
120  type_get() */
121 _union_type_get(const void *data,
122  Eina_Bool *unknow)
123 {
124  const Example_Data_Type *u = data;
125  int i;
126 
127  if (unknow)
128  *unknow = EINA_FALSE;
129 
130  for (i = 0; eet_mapping[i].name != NULL; ++i)
131  if (*u == eet_mapping[i].u)
132  return eet_mapping[i].name;
133 
134  if (unknow)
135  *unknow = EINA_TRUE;
136 
137  return NULL;
138 } /* _union_type_get */
139 
140 static Eina_Bool
141 _union_type_set(const char *type,
142  void *data,
143  Eina_Bool unknow)
144 {
145  Example_Data_Type *u = data;
146  int i;
147 
148  if (unknow)
149  return EINA_FALSE;
150 
151  for (i = 0; eet_mapping[i].name != NULL; ++i)
152  if (strcmp(eet_mapping[i].name, type) == 0)
153  {
154  *u = eet_mapping[i].u;
155  return EINA_TRUE;
156  }
157 
158  return EINA_FALSE;
159 } /* _union_type_set */
160 
161 static const char *
162 _variant_type_get(const void *data,
163  Eina_Bool *unknow)
164 {
165  const Example_Variant_Type *type = data;
166  int i;
167 
168  if (unknow)
169  *unknow = type->unknow;
170 
171  for (i = 0; eet_mapping[i].name != NULL; ++i)
172  if (strcmp(type->type, eet_mapping[i].name) == 0)
173  return eet_mapping[i].name;
174 
175  if (unknow)
176  *unknow = EINA_FALSE;
177 
178  return type->type;
179 } /* _variant_type_get */
180 
181 static Eina_Bool
182 _variant_type_set(const char *type,
183  void *data,
184  Eina_Bool unknow)
185 {
186  Example_Variant_Type *vt = data;
187 
188  vt->type = type;
189  vt->unknow = unknow;
190  return EINA_TRUE;
191 } /* _variant_type_set */
192 
193 static Eet_Data_Descriptor *
194 _st1_dd(void)
195 {
197  Eet_Data_Descriptor *res;
198 
199  EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Struct1);
200  res = eet_data_descriptor_file_new(&eddc);
202  res, Example_Struct1, "val1", val1, EET_T_DOUBLE);
204  res, Example_Struct1, "stuff", stuff, EET_T_INT);
206  res, Example_Struct1, "s1", s1, EET_T_STRING);
207 
208  return res;
209 } /* _st1_dd */
210 
211 static Eet_Data_Descriptor *
212 _st2_dd(void)
213 {
215  Eet_Data_Descriptor *res;
216 
217  EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Struct2);
218  res = eet_data_descriptor_file_new(&eddc);
220  res, Example_Struct2, "b1", b1, EET_T_UCHAR);
222  res, Example_Struct2, "v1", v1, EET_T_ULONG_LONG);
223 
224  return res;
225 } /* _st2_dd */
226 
227 static Eet_Data_Descriptor *
228 _st3_dd(void)
229 {
231  Eet_Data_Descriptor *res;
232 
233  EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Struct3);
234  res = eet_data_descriptor_file_new(&eddc);
236  res, Example_Struct3, "body", body, EET_T_INT);
237 
238  return res;
239 } /* _st3_dd */
240 
241 /* string that represents the entry in the eet file. you might like to
242  * have different profiles or so in the same file, this is possible
243  * with different strings
244  */
245 static const char CACHE_FILE_ENTRY[] = "cache";
246 
247 /* keep the descriptor static global, so it can be shared by different
248  * functions (load/save) of this and only this file.
249  */
250 static Eet_Data_Descriptor *_lists_descriptor;
251 static Eet_Data_Descriptor *_struct_1_descriptor;
252 static Eet_Data_Descriptor *_struct_2_descriptor;
253 static Eet_Data_Descriptor *_struct_3_descriptor;
254 static Eet_Data_Descriptor *_union_descriptor;
255 static Eet_Data_Descriptor *_variant_descriptor;
256 static Eet_Data_Descriptor *_union_unified_descriptor;
257 static Eet_Data_Descriptor *_variant_unified_descriptor;
258 
259 /* keep file handle alive, so mmap()ed strings are all alive as
260  * well */
261 static Eet_File *_cache_file = NULL;
262 static Eet_Dictionary *_cache_dict = NULL;
263 
264 static void
265 /* declaring types */
266 _data_descriptors_init(void)
267 {
269 
270  EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Lists);
271  _lists_descriptor = eet_data_descriptor_file_new(&eddc);
272 
273  _struct_1_descriptor = _st1_dd();
274  _struct_2_descriptor = _st2_dd();
275  _struct_3_descriptor = _st3_dd();
276 
277  /* for union */
278  EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Union);
279  _union_descriptor = eet_data_descriptor_file_new(&eddc);
280 
282  eddc.func.type_get = _union_type_get;
283  eddc.func.type_set = _union_type_set;
284  _union_unified_descriptor = eet_data_descriptor_file_new(&eddc);
285 
287  _union_unified_descriptor, "ST1", _struct_1_descriptor);
289  _union_unified_descriptor, "ST2", _struct_2_descriptor);
291  _union_unified_descriptor, "ST3", _struct_3_descriptor);
292 
294  _union_descriptor, Example_Union, "u", u, type,
295  _union_unified_descriptor);
296 
298  _lists_descriptor, Example_Lists, "union_list", union_list,
299  _union_descriptor);
300 
301  /* for variant */
302  EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Example_Variant);
303  _variant_descriptor = eet_data_descriptor_file_new(&eddc);
304 
306  eddc.func.type_get = _variant_type_get;
307  eddc.func.type_set = _variant_type_set;
308  _variant_unified_descriptor = eet_data_descriptor_stream_new(&eddc);
309 
311  _variant_unified_descriptor, "ST1", _struct_1_descriptor);
313  _variant_unified_descriptor, "ST2", _struct_2_descriptor);
315  _variant_unified_descriptor, "ST3", _struct_3_descriptor);
316 
318  _variant_descriptor, Example_Variant, "data", data, t,
319  _variant_unified_descriptor);
320 
322  _lists_descriptor, Example_Lists, "variant_list", variant_list,
323  _variant_descriptor);
324 } /* _data_descriptors_init */
325 
326 static void
327 _data_descriptors_shutdown(void)
328 {
329  eet_data_descriptor_free(_lists_descriptor);
330  eet_data_descriptor_free(_struct_1_descriptor);
331  eet_data_descriptor_free(_struct_2_descriptor);
332  eet_data_descriptor_free(_struct_3_descriptor);
333  eet_data_descriptor_free(_union_descriptor);
334  eet_data_descriptor_free(_variant_descriptor);
335  eet_data_descriptor_free(_union_unified_descriptor);
336  eet_data_descriptor_free(_variant_unified_descriptor);
337 } /* _data_descriptors_shutdown */
338 
339 /* need to check if the pointer came from mmap()ed area in
340  * eet_dictionary or it was allocated with eina_stringshare_add()
341  */
342 static void
343 _string_free(const char *str)
344 {
345  if (!str)
346  return;
347 
348  if ((_cache_dict) && (eet_dictionary_string_check(_cache_dict, str)))
349  return;
350 
351  eina_stringshare_del(str);
352 } /* _string_free */
353 
354 static Example_Union *
355 _union_1_new(const char *v1,
356  const char *v2,
357  const char *v3)
358 {
359  Example_Union *un = calloc(1, sizeof(Example_Union));
360  if (!un)
361  {
362  fprintf(
363  stderr, "ERROR: could not allocate an Example_Union struct.\n");
364  return NULL;
365  }
366 
367  un->type = EET_STRUCT1;
368  _st1_set(&(un->u.st1), atof(v1), atoi(v2), eina_stringshare_add(v3));
369 
370  return un;
371 }
372 
373 static Example_Union *
374 _union_2_new(const char *v1,
375  const char *v2)
376 {
377  Example_Union *un = calloc(1, sizeof(Example_Union));
378  if (!un)
379  {
380  fprintf(
381  stderr, "ERROR: could not allocate an Example_Union struct.\n");
382  return NULL;
383  }
384 
385  un->type = EET_STRUCT2;
386  _st2_set(&(un->u.st2), atoi(v1), atoi(v2));
387 
388  return un;
389 }
390 
391 static Example_Union *
392 _union_3_new(const char *v1)
393 {
394  Example_Union *un = calloc(1, sizeof(Example_Union));
395  if (!un)
396  {
397  fprintf(
398  stderr, "ERROR: could not allocate an Example_Union struct.\n");
399  return NULL;
400  }
401 
402  un->type = EET_STRUCT3;
403  _st3_set(&(un->u.st3), atoi(v1));
404 
405  return un;
406 }
407 
408 static Example_Variant *
409 _variant_1_new(const char *v1,
410  const char *v2,
411  const char *v3)
412 {
413  Example_Struct1 *st1;
414  Example_Variant *va = calloc(1, sizeof(Example_Variant));
415  if (!va)
416  {
417  fprintf(
418  stderr, "ERROR: could not allocate an Example_Variant struct.\n");
419  return NULL;
420  }
421 
422  va = calloc(1, sizeof (Example_Variant));
423  va->t.type = eet_mapping[0].name;
424  st1 = calloc(1, sizeof (Example_Struct1));
425  _st1_set(st1, atof(v1), atoi(v2), eina_stringshare_add(v3));
426  va->data = st1;
427 
428  return va;
429 }
430 
431 static Example_Variant *
432 _variant_2_new(const char *v1,
433  const char *v2)
434 {
435  printf("varinant 2 new\n");
436 
437  Example_Struct2 *st2;
438  Example_Variant *va = calloc(1, sizeof(Example_Variant));
439  if (!va)
440  {
441  fprintf(
442  stderr, "ERROR: could not allocate an Example_Variant struct.\n");
443  return NULL;
444  }
445 
446  va = calloc(1, sizeof (Example_Variant));
447 
448  va->t.type = eet_mapping[1].name;
449 
450  printf("type gets %s\n", va->t.type);
451 
452  st2 = calloc(1, sizeof (Example_Struct2));
453  _st2_set(st2, atoi(v1), atoi(v2));
454  va->data = st2;
455 
456  return va;
457 }
458 
459 static Example_Variant *
460 _variant_3_new(const char *v1)
461 {
462  Example_Struct3 *st3;
463  Example_Variant *va = calloc(1, sizeof(Example_Variant));
464  if (!va)
465  {
466  fprintf(
467  stderr, "ERROR: could not allocate an Example_Variant struct.\n");
468  return NULL;
469  }
470 
471  va = calloc(1, sizeof (Example_Variant));
472  va->t.type = eet_mapping[2].name;
473  st3 = calloc(1, sizeof (Example_Struct3));
474  _st3_set(st3, atoi(v1));
475  va->data = st3;
476 
477  return va;
478 }
479 
480 static Example_Lists *
481 _data_new(void)
482 {
483  Example_Lists *example_lists = calloc(1, sizeof(Example_Lists));
484  if (!example_lists)
485  {
486  fprintf(stderr, "ERROR: could not allocate a Example_Lists struct.\n");
487  return NULL;
488  }
489 
490  return example_lists;
491 } /* _data_new */
492 
493 static void
494 _union_free(Example_Union *un)
495 {
496  if (un->type == EET_STRUCT1)
497  {
498  Example_Struct1 *st1 = &(un->u.st1);
499  _string_free(st1->s1);
500  }
501 
502  free(un);
503 }
504 
505 static void
506 _variant_free(Example_Variant *va)
507 {
508  if (!strcmp(va->t.type, eet_mapping[0].name))
509  {
510  Example_Struct1 *st1 = va->data;
511  _string_free(st1->s1);
512  }
513 
514  free(va->data);
515  free(va);
516 }
517 
518 static void
519 _data_free(Example_Lists *cache)
520 {
521  Example_Union *un;
522  Example_Variant *va;
523 
524  EINA_LIST_FREE(cache->union_list, un)
525  _union_free(un);
526 
527  EINA_LIST_FREE(cache->variant_list, va)
528  _variant_free(va);
529 
530  free(cache);
531 } /* _data_free */
532 
533 static Example_Lists *
534 _data_load(const char *filename)
535 {
536  Example_Lists *data;
537  Eet_File *ef = eet_open(filename, EET_FILE_MODE_READ);
538  if (!ef)
539  {
540  fprintf(stderr, "ERROR: could not open '%s' for read\n", filename);
541  return NULL;
542  }
543 
544  data = eet_data_read(ef, _lists_descriptor, CACHE_FILE_ENTRY);
545  if (!data)
546  {
547  eet_close(ef);
548  return NULL;
549  }
550 
551  if (_cache_file)
552  eet_close(_cache_file);
553 
554  _cache_file = ef;
555  _cache_dict = eet_dictionary_get(ef);
556 
557  return data;
558 } /* _data_load */
559 
560 static Eina_Bool
561 _data_save(const Example_Lists *cache,
562  const char *filename)
563 {
564  char tmp[PATH_MAX];
565  Eet_File *ef;
566  Eina_Bool ret;
567  unsigned int i, len;
568  struct stat st;
569 
570  len = eina_strlcpy(tmp, filename, sizeof(tmp));
571  if (len + 12 >= (int)sizeof(tmp))
572  {
573  fprintf(stderr, "ERROR: file name is too big: %s\n", filename);
574  return EINA_FALSE;
575  }
576 
577  i = 0;
578  do
579  {
580  snprintf(tmp + len, 12, ".%u", i);
581  i++;
582  }
583  while (stat(tmp, &st) == 0);
584 
585  ef = eet_open(tmp, EET_FILE_MODE_WRITE);
586  if (!ef)
587  {
588  fprintf(stderr, "ERROR: could not open '%s' for write\n", tmp);
589  return EINA_FALSE;
590  }
591 
592  ret = eet_data_write
593  (ef, _lists_descriptor, CACHE_FILE_ENTRY, cache, EINA_TRUE);
594 
595  eet_close(ef);
596 
597  if (ret)
598  {
599  unlink(filename);
600  rename(tmp, filename);
601  }
602 
603  return ret;
604 } /* _data_save */
605 
606 static void
607 _print_union(const Example_Union *un)
608 {
609  printf("\t | type: %s'\n", eet_mapping[un->type - 1].name);
610 
611  switch (un->type)
612  {
613  case EET_STRUCT1:
614  printf("\t\t val1: %f\n", un->u.st1.val1);
615  printf("\t\t stuff: %d\n", un->u.st1.stuff);
616  printf("\t\t s1: %s\n", un->u.st1.s1);
617  break;
618 
619  case EET_STRUCT2:
620  printf("\t\t val1: %i\n", un->u.st2.b1);
621  printf("\t\t stuff: %lli\n", un->u.st2.v1);
622  break;
623 
624  case EET_STRUCT3:
625  printf("\t\t val1: %i\n", un->u.st3.body);
626  break;
627 
628  default:
629  return;
630  }
631 }
632 
633 static void
634 _print_variant(const Example_Variant *va)
635 {
636  printf("\t | type: %s'\n", va->t.type);
637 
638  switch (va->t.type[2])
639  {
640  case '1':
641  {
642  Example_Struct1 *st1 = va->data;
643 
644  printf("\t\t val1: %f\n", st1->val1);
645  printf("\t\t stuff: %d\n", st1->stuff);
646  printf("\t\t s1: %s\n", st1->s1);
647  }
648  break;
649 
650  case '2':
651  {
652  Example_Struct2 *st2 = va->data;
653 
654  printf("\t\t val1: %i\n", st2->b1);
655  printf("\t\t stuff: %lli\n", st2->v1);
656  }
657  break;
658 
659  case '3':
660  {
661  Example_Struct3 *st3 = va->data;
662 
663  printf("\t\t val1: %i\n", st3->body);
664  }
665  break;
666 
667  default:
668  return;
669  }
670 }
671 
672 int
673 main(int argc,
674  char *argv[])
675 {
676  Example_Lists *data_lists;
677  int ret = 0;
678 
679  if (argc < 3)
680  {
681  fprintf(stderr,
682  "Usage:\n\t%s <input> <output> [action action-params]\n\n"
683  "where actions and their parameters are:\n"
684  "\tunion <type> [fields]\n"
685  "\tvariant <type> [fields]\n"
686  "\n",
687  argv[0]);
688  return -1;
689  }
690 
691  eina_init();
692  eet_init();
693  _data_descriptors_init();
694 
695  data_lists = _data_load(argv[1]);
696  if (!data_lists)
697  {
698  printf("Creating new data lists.\n");
699  data_lists = _data_new();
700  if (!data_lists)
701  {
702  ret = -2;
703  goto end;
704  }
705  }
706 
707  if (argc > 3)
708  {
709  if (strcmp(argv[3], "union") == 0)
710  {
711  if (argc > 4)
712  {
713  int type = atoi(argv[4]);
714  Example_Union *un;
715 
716  if (type < EET_STRUCT1 || type > EET_STRUCT3)
717  {
718  fprintf(stderr,
719  "ERROR: invalid type parameter (%s).\n",
720  argv[4]);
721  goto cont;
722  }
723 
724  switch (type)
725  {
726  case 1:
727  if (argc != 8)
728  {
729  fprintf(
730  stderr, "ERROR: wrong number of parameters"
731  " (%d).\n", argc);
732  goto cont;
733  }
734 
735  un = _union_1_new(
736  argv[5], argv[6], argv[7]);
737  if (!un)
738  {
739  fprintf(
740  stderr, "ERROR: could not create the "
741  "requested union.\n");
742  goto cont;
743  }
744  data_lists->union_list =
745  eina_list_append(data_lists->union_list, un);
746  break;
747 
748  case 2:
749  if (argc != 7)
750  {
751  fprintf(
752  stderr, "ERROR: wrong number of parameters"
753  " (%d).\n", argc);
754  goto cont;
755  }
756 
757  un = _union_2_new(argv[5], argv[6]);
758  if (!un)
759  {
760  fprintf(
761  stderr, "ERROR: could not create the "
762  "requested union.\n");
763  goto cont;
764  }
765  data_lists->union_list =
766  eina_list_append(data_lists->union_list, un);
767  break;
768 
769  case 3:
770  if (argc != 6)
771  {
772  fprintf(
773  stderr, "ERROR: wrong number of parameters"
774  " (%d).\n", argc);
775  goto cont;
776  }
777 
778  un = _union_3_new(argv[5]);
779  if (!un)
780  {
781  fprintf(
782  stderr, "ERROR: could not create the "
783  "requested union.\n");
784  goto cont;
785  }
786  data_lists->union_list =
787  eina_list_append(data_lists->union_list, un);
788  break;
789 
790  default:
791  fprintf(
792  stderr, "ERROR: bad type of of struct passed\n");
793  goto cont;
794  }
795  }
796  else
797  fprintf(stderr,
798  "ERROR: wrong number of parameters (%d).\n",
799  argc);
800  }
801  else if (strcmp(argv[3], "variant") == 0)
802  {
803  if (argc > 4)
804  {
805  int type = atoi(argv[4]);
806  Example_Variant *va;
807 
808  if (type < EET_STRUCT1 || type > EET_STRUCT3)
809  {
810  fprintf(stderr,
811  "ERROR: invalid type parameter (%s).\n",
812  argv[4]);
813  goto cont;
814  }
815 
816  switch (type)
817  {
818  case 1:
819  if (argc != 8)
820  {
821  fprintf(
822  stderr, "ERROR: wrong number of parameters"
823  " (%d).\n", argc);
824  goto cont;
825  }
826 
827  va = _variant_1_new(
828  argv[5], argv[6], argv[7]);
829  if (!va)
830  {
831  fprintf(
832  stderr, "ERROR: could not create the "
833  "requested variant.\n");
834  goto cont;
835  }
836  data_lists->variant_list =
837  eina_list_append(data_lists->variant_list, va);
838  break;
839 
840  case 2:
841  if (argc != 7)
842  {
843  fprintf(
844  stderr, "ERROR: wrong number of parameters"
845  " (%d).\n", argc);
846  goto cont;
847  }
848 
849  va = _variant_2_new(argv[5], argv[6]);
850  if (!va)
851  {
852  fprintf(
853  stderr, "ERROR: could not create the "
854  "requested variant.\n");
855  goto cont;
856  }
857  data_lists->variant_list =
858  eina_list_append(data_lists->variant_list, va);
859  break;
860 
861  case 3:
862  if (argc != 6)
863  {
864  fprintf(
865  stderr, "ERROR: wrong number of parameters"
866  " (%d).\n", argc);
867  goto cont;
868  }
869 
870  va = _variant_3_new(argv[5]);
871  if (!va)
872  {
873  fprintf(
874  stderr, "ERROR: could not create the "
875  "requested variant.\n");
876  goto cont;
877  }
878  data_lists->variant_list =
879  eina_list_append(data_lists->variant_list, va);
880  break;
881 
882  default:
883  fprintf(
884  stderr, "ERROR: bad type of of struct passed\n");
885  goto cont;
886  }
887  }
888  else
889  fprintf(stderr,
890  "ERROR: wrong number of parameters (%d).\n",
891  argc);
892  }
893  else
894  fprintf(stderr, "ERROR: unknown action '%s'\n", argv[3]);
895  }
896 
897 cont:
898  printf("Cached data:\n");
899 
900  printf("\tstats: unions=%u, variants=%u\n",
901  eina_list_count(data_lists->union_list),
902  eina_list_count(data_lists->variant_list));
903 
904  if (eina_list_count(data_lists->union_list))
905  {
906  const Eina_List *l;
907  const Example_Union *un;
908  printf("\t * union list:\n");
909 
910  EINA_LIST_FOREACH(data_lists->union_list, l, un)
911  {
912  _print_union(un);
913  }
914  }
915 
916  if (eina_list_count(data_lists->variant_list))
917  {
918  const Eina_List *l;
919  const Example_Variant *un;
920  printf("\t * variant list:\n");
921 
922  EINA_LIST_FOREACH(data_lists->variant_list, l, un)
923  {
924  _print_variant(un);
925  }
926  }
927 
928  printf("\n");
929 
930  if (!_data_save(data_lists, argv[2]))
931  ret = -3;
932 
933  _data_free(data_lists);
934 
935 end:
936  if (_cache_file)
937  eet_close(_cache_file);
938  _data_descriptors_shutdown();
939  eet_shutdown();
940  eina_shutdown();
941 
942  return ret;
943 } /* main */
944 
EAPI Eet_File * eet_open(const char *file, Eet_File_Mode mode)
Open an eet file on disk, and returns a handle to it.
Definition: eet_lib.c:1419
int version
ABI version.
Definition: Eet.h:2457
EAPI int eet_data_write(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name, const void *data, int compress)
Write a data structure from memory and store in an eet file.
Definition: eet_data.c:2164
Definition: Eet_private.h:74
#define EET_DATA_DESCRIPTOR_ADD_UNION(edd, struct_type, name, member, type_member, unified_type)
Add an union type to a data descriptor.
Definition: Eet.h:3351
File is read-only.
Definition: Eet.h:513
EAPI int eet_shutdown(void)
Shut down the EET library.
Definition: eet_lib.c:634
Eet_Descriptor_Type_Get_Callback type_get
get the type, as used in the union or variant mapping, that should be used to store the given data in...
Definition: Eet.h:2475
EAPI void eet_data_descriptor_free(Eet_Data_Descriptor *edd)
This function frees a data descriptor when it is not needed anymore.
Definition: eet_data.c:1920
#define EET_T_STRING
Data type: char *.
Definition: Eet.h:2363
#define EET_T_UCHAR
Data type: unsigned char.
Definition: Eet.h:2359
EAPI int eet_dictionary_string_check(Eet_Dictionary *ed, const char *string)
Check if a given string comes from a given dictionary.
Definition: eet_dictionary.c:486
#define EET_T_INT
Data type: int.
Definition: Eet.h:2355
The file that provides the eet functions.
File is write-only.
Definition: Eet.h:514
#define EET_DATA_DESCRIPTOR_ADD_MAPPING(unified_type, name, subtype)
Add a mapping to a data descriptor that will be used by union, variant or inherited type...
Definition: Eet.h:3404
#define EET_DATA_DESCRIPTOR_CLASS_VERSION
The version of Eet_Data_Descriptor_Class at the time of the distribution of the sources.
Definition: Eet.h:2412
EAPI Eet_Data_Descriptor * eet_data_descriptor_stream_new(const Eet_Data_Descriptor_Class *eddc)
This function creates a new data descriptor and returns a handle to the new data descriptor.
Definition: eet_data.c:1908
#define EET_DATA_DESCRIPTOR_ADD_VARIANT(edd, struct_type, name, member, type_member, unified_type)
Add a automatically selectable type to a data descriptor.
Definition: Eet.h:3383
EAPI void * eet_data_read(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name)
Read a data structure from an eet file and decodes it.
Definition: eet_data.c:2132
Instructs Eet about memory management for different needs under serialization and parse process...
Definition: Eet.h:2455
#define EET_DATA_DESCRIPTOR_ADD_BASIC(edd, struct_type, name, member, type)
Add a basic data element to a data descriptor.
Definition: Eet.h:3040
#define EET_T_DOUBLE
Data type: double.
Definition: Eet.h:2358
#define EET_DATA_DESCRIPTOR_ADD_LIST(edd, struct_type, name, member, subtype)
Add a linked list type to a data descriptor.
Definition: Eet.h:3093
EAPI Eet_Error eet_close(Eet_File *ef)
Close an eet file handle and flush pending writes.
Definition: eet_lib.c:1659
#define EET_T_ULONG_LONG
Data type: unsigned long long.
Definition: Eet.h:2362
struct _Eet_Data_Descriptor Eet_Data_Descriptor
Opaque handle that have information on a type members.
Definition: Eet.h:2403
EAPI Eet_Data_Descriptor * eet_data_descriptor_file_new(const Eet_Data_Descriptor_Class *eddc)
This function creates a new data descriptor and returns a handle to the new data descriptor.
Definition: eet_data.c:1914
Eet_Descriptor_Type_Set_Callback type_set
called when loading a mapped type with the given type used to describe the type in the descriptor ...
Definition: Eet.h:2476
Definition: Eet_private.h:40
#define EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(clas, type)
This macro is an helper that set all the parameter of an Eet_Data_Descriptor_Class correctly when you...
Definition: Eet.h:2702
EAPI Eet_Dictionary * eet_dictionary_get(Eet_File *ef)
Return a handle to the shared string dictionary of the Eet file.
Definition: eet_lib.c:2553
EAPI int eet_init(void)
Initialize the EET library.
Definition: eet_lib.c:553