1 /* Eina - EFL data type library
2 * Copyright (C) 2012 ProFUSION embedded systems
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library;
16 * if not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #ifndef EINA_INLINE_VALUE_X_
20 #define EINA_INLINE_VALUE_X_
21
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include "eina_stringshare.h"
26
27 /* NOTE: most of value is implemented here for performance reasons */
28
29 //#define EINA_VALUE_NO_OPTIMIZE 1
30 #ifdef EINA_VALUE_NO_OPTIMIZE
31 #define EINA_VALUE_TYPE_DEFAULT(type) (0)
32 #else
33
34 /**
35 * @var _EINA_VALUE_TYPE_BASICS_START
36 * pointer to the first basic type.
37 * @since 1.2
38 * @private
39 */
40 EAPI extern const Eina_Value_Type *_EINA_VALUE_TYPE_BASICS_START;
41
42 /**
43 * @var _EINA_VALUE_TYPE_BASICS_END
44 * pointer to the last (inclusive) basic type.
45 * @since 1.2
46 * @private
47 */
48 EAPI extern const Eina_Value_Type *_EINA_VALUE_TYPE_BASICS_END;
49 #define EINA_VALUE_TYPE_DEFAULT(type) \
50 ((_EINA_VALUE_TYPE_BASICS_START <= type) && \
51 (type <= _EINA_VALUE_TYPE_BASICS_END))
52 #endif
53
54 #define EINA_VALUE_TYPE_CHECK_RETURN(value) \
55 EINA_SAFETY_ON_NULL_RETURN(value); \
56 EINA_SAFETY_ON_FALSE_RETURN(eina_value_type_check(value->type))
57
58 #define EINA_VALUE_TYPE_CHECK_RETURN_VAL(value, retval) \
59 EINA_SAFETY_ON_NULL_RETURN_VAL(value, retval); \
60 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(value->type), retval)
61
62 #define EINA_VALUE_TYPE_DISPATCH(type, method, no_method_err, ...) \
63 do \
64 { \
65 if (type->method) \
66 type->method(type, ##__VA_ARGS__); \
67 } \
68 while (0)
69
70 #define EINA_VALUE_TYPE_DISPATCH_RETURN(value, method, no_method_err, def_ret, ...) \
71 do \
72 { \
73 if (type->method) \
74 return type->method(type, ##__VA_ARGS__); \
75 return def_ret; \
76 } \
77 while (0)
78
79 /**
80 * @brief Get memory for given value (inline or allocated buffer).
81 * @since 1.2
82 * @private
83 */
84 static inline void *
eina_value_memory_get(const Eina_Value * value)85 eina_value_memory_get(const Eina_Value *value)
86 {
87 if (value->type->value_size <= 8)
88 return (void *)value->value.buf;
89 return value->value.ptr;
90 }
91
92 /**
93 * @brief Allocate memory for internal value types.
94 * @since 1.2
95 * @private
96 */
97 EAPI void *eina_value_inner_alloc(size_t size);
98 /**
99 * @brief Releases memory for internal value types.
100 * @since 1.2
101 * @private
102 */
103 EAPI void eina_value_inner_free(size_t size, void *mem);
104
105 static inline Eina_Bool
eina_value_setup(Eina_Value * value,const Eina_Value_Type * type)106 eina_value_setup(Eina_Value *value, const Eina_Value_Type *type)
107 {
108 void *mem;
109
110 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
111 EINA_SAFETY_ON_FALSE_RETURN_VAL(type->value_size > 0, EINA_FALSE);
112
113 value->type = type;
114
115 if (type->value_size <= 8) mem = &value->value;
116 else
117 {
118 mem = value->value.ptr = eina_value_inner_alloc(type->value_size);
119 EINA_SAFETY_ON_NULL_RETURN_VAL(mem, EINA_FALSE);
120 }
121
122 memset(mem, 0, type->value_size);
123
124 if (EINA_VALUE_TYPE_DEFAULT(type))
125 {
126 return EINA_TRUE;
127 }
128
129 EINA_VALUE_TYPE_DISPATCH_RETURN(type, setup,
130 0, EINA_FALSE, mem);
131 }
132
133 static inline void
eina_value_flush(Eina_Value * value)134 eina_value_flush(Eina_Value *value)
135 {
136 const Eina_Value_Type *type;
137 void *mem;
138
139 if (!value || !value->type) return;
140 EINA_VALUE_TYPE_CHECK_RETURN(value);
141
142 type = value->type;
143 mem = eina_value_memory_get(value);
144
145 if (EINA_VALUE_TYPE_DEFAULT(type))
146 {
147 if (type == EINA_VALUE_TYPE_STRINGSHARE)
148 {
149 if (value->value.ptr) eina_stringshare_del((const char*) value->value.ptr);
150 }
151 else if (type == EINA_VALUE_TYPE_STRING)
152 {
153 if (value->value.ptr)
154 {
155 free(value->value.ptr);
156 value->value.ptr = NULL;
157 }
158 }
159 else if (type->value_size > 8)
160 eina_value_inner_free(type->value_size, mem);
161 return;
162 }
163
164 EINA_VALUE_TYPE_DISPATCH(type, flush, 0, mem);
165 if (type->value_size > 8)
166 eina_value_inner_free(type->value_size, mem);
167 value->type = NULL;
168 }
169
170 static inline int
eina_value_compare(const Eina_Value * a,const Eina_Value * b)171 eina_value_compare(const Eina_Value *a, const Eina_Value *b)
172 {
173 const Eina_Value_Type *type;
174 void *pa, *pb;
175
176 EINA_VALUE_TYPE_CHECK_RETURN_VAL(a, -1);
177 EINA_SAFETY_ON_NULL_RETURN_VAL(b, -1);
178 EINA_SAFETY_ON_FALSE_RETURN_VAL(a->type == b->type, -1);
179
180 type = a->type;
181 pa = eina_value_memory_get(a);
182 pb = eina_value_memory_get(b);
183
184 #ifndef EINA_VALUE_NO_OPTIMIZE
185 if (type == EINA_VALUE_TYPE_UCHAR)
186 {
187 unsigned char *ta = (unsigned char *) pa, *tb = (unsigned char *) pb;
188 if (*ta < *tb)
189 return -1;
190 else if (*ta > *tb)
191 return 1;
192 return 0;
193 }
194 else if (type == EINA_VALUE_TYPE_USHORT)
195 {
196 unsigned short *ta = (unsigned short *) pa, *tb = (unsigned short *) pb;
197 if (*ta < *tb)
198 return -1;
199 else if (*ta > *tb)
200 return 1;
201 return 0;
202 }
203 else if (type == EINA_VALUE_TYPE_UINT)
204 {
205 unsigned int *ta = (unsigned int *) pa, *tb = (unsigned int *) pb;
206 if (*ta < *tb)
207 return -1;
208 else if (*ta > *tb)
209 return 1;
210 return 0;
211 }
212 else if ((type == EINA_VALUE_TYPE_ULONG) || (type == EINA_VALUE_TYPE_TIMESTAMP))
213 {
214 unsigned long *ta = (unsigned long *) pa, *tb = (unsigned long *) pb;
215 if (*ta < *tb)
216 return -1;
217 else if (*ta > *tb)
218 return 1;
219 return 0;
220 }
221 else if (type == EINA_VALUE_TYPE_UINT64)
222 {
223 uint64_t *ta = (uint64_t *) pa, *tb = (uint64_t *) pb;
224 if (*ta < *tb)
225 return -1;
226 else if (*ta > *tb)
227 return 1;
228 return 0;
229 }
230 else if (type == EINA_VALUE_TYPE_CHAR)
231 {
232 signed char *ta = (signed char *) pa, *tb = (signed char *) pb;
233 if (*ta < *tb)
234 return -1;
235 else if (*ta > *tb)
236 return 1;
237 return 0;
238 }
239 else if (type == EINA_VALUE_TYPE_SHORT)
240 {
241 short *ta = (short *) pa, *tb = (short *) pb;
242 if (*ta < *tb)
243 return -1;
244 else if (*ta > *tb)
245 return 1;
246 return 0;
247 }
248 else if (type == EINA_VALUE_TYPE_INT)
249 {
250 int *ta = (int *) pa, *tb = (int *) pb;
251 if (*ta < *tb)
252 return -1;
253 else if (*ta > *tb)
254 return 1;
255 return 0;
256 }
257 else if (type == EINA_VALUE_TYPE_LONG)
258 {
259 long *ta = (long *) pa, *tb = (long *) pb;
260 if (*ta < *tb)
261 return -1;
262 else if (*ta > *tb)
263 return 1;
264 return 0;
265 }
266 else if (type == EINA_VALUE_TYPE_INT64)
267 {
268 int64_t *ta = (int64_t *) pa, *tb = (int64_t *) pb;
269 if (*ta < *tb)
270 return -1;
271 else if (*ta > *tb)
272 return 1;
273 return 0;
274 }
275 else if (type == EINA_VALUE_TYPE_FLOAT)
276 {
277 float *ta = (float *) pa, *tb = (float *) pb;
278 if (*ta < *tb)
279 return -1;
280 else if (*ta > *tb)
281 return 1;
282 return 0;
283 }
284 else if (type == EINA_VALUE_TYPE_DOUBLE)
285 {
286 double *ta = (double *) pa, *tb = (double *) pb;
287 if (*ta < *tb)
288 return -1;
289 else if (*ta > *tb)
290 return 1;
291 return 0;
292 }
293 else if (type == EINA_VALUE_TYPE_STRINGSHARE ||
294 type == EINA_VALUE_TYPE_STRING)
295 {
296 const char *sa = *(const char **)pa;
297 const char *sb = *(const char **)pb;
298 if (sa == sb)
299 return 0;
300 if (sa == NULL)
301 return -1;
302 if (sb == NULL)
303 return 1;
304 return strcmp(sa, sb);
305 }
306 #endif
307
308 EINA_VALUE_TYPE_DISPATCH_RETURN(type, compare, 0,
309 EINA_FALSE, pa, pb);
310 }
311
312 static inline Eina_Bool
eina_value_set(Eina_Value * value,...)313 eina_value_set(Eina_Value *value, ...)
314 {
315 va_list args;
316 Eina_Bool ret;
317 va_start(args, value);
318 ret = eina_value_vset(value, args);
319 va_end(args);
320 return ret;
321 }
322
323 static inline Eina_Bool
eina_value_get(const Eina_Value * value,...)324 eina_value_get(const Eina_Value *value, ...)
325 {
326 va_list args;
327 Eina_Bool ret;
328 va_start(args, value);
329 ret = eina_value_vget(value, args);
330 va_end(args);
331 return ret;
332 }
333
334 static inline Eina_Bool
eina_value_vset(Eina_Value * value,va_list args)335 eina_value_vset(Eina_Value *value, va_list args)
336 {
337 const Eina_Value_Type *type;
338 void *mem;
339 va_list args_copy;
340 Eina_Bool r = EINA_FALSE;
341
342 EINA_VALUE_TYPE_CHECK_RETURN_VAL(value, EINA_FALSE);
343
344 type = value->type;
345 mem = eina_value_memory_get(value);
346 #ifndef EINA_VALUE_NO_OPTIMIZE
347 if (type == EINA_VALUE_TYPE_UCHAR)
348 {
349 unsigned char *tmem = (unsigned char *) mem;
350 *tmem = va_arg(args, unsigned int); /* promoted by va_arg */
351 return EINA_TRUE;
352 }
353 else if (type == EINA_VALUE_TYPE_USHORT)
354 {
355 unsigned short *tmem = (unsigned short *) mem;
356 *tmem = va_arg(args, unsigned int); /* promoted by va_arg */
357 return EINA_TRUE;
358 }
359 else if (type == EINA_VALUE_TYPE_UINT)
360 {
361 unsigned int *tmem = (unsigned int *) mem;
362 *tmem = va_arg(args, unsigned int);
363 return EINA_TRUE;
364 }
365 else if ((type == EINA_VALUE_TYPE_ULONG) || (type == EINA_VALUE_TYPE_TIMESTAMP))
366 {
367 unsigned long *tmem = (unsigned long *) mem;
368 *tmem = va_arg(args, unsigned long);
369 return EINA_TRUE;
370 }
371 else if (type == EINA_VALUE_TYPE_UINT64)
372 {
373 uint64_t *tmem = (uint64_t *) mem;
374 *tmem = va_arg(args, uint64_t);
375 return EINA_TRUE;
376 }
377 else if (type == EINA_VALUE_TYPE_CHAR)
378 {
379 signed char *tmem = (signed char *) mem;
380 *tmem = va_arg(args, int); /* promoted by va_arg */
381 return EINA_TRUE;
382 }
383 else if (type == EINA_VALUE_TYPE_SHORT)
384 {
385 short *tmem = (short *) mem;
386 *tmem = va_arg(args, int); /* promoted by va_arg */
387 return EINA_TRUE;
388 }
389 else if (type == EINA_VALUE_TYPE_INT)
390 {
391 int *tmem = (int *) mem;
392 *tmem = va_arg(args, int);
393 return EINA_TRUE;
394 }
395 else if (type == EINA_VALUE_TYPE_LONG)
396 {
397 long *tmem = (long *) mem;
398 *tmem = va_arg(args, long);
399 return EINA_TRUE;
400 }
401 else if (type == EINA_VALUE_TYPE_INT64)
402 {
403 int64_t *tmem = (int64_t *) mem;
404 *tmem = va_arg(args, int64_t);
405 return EINA_TRUE;
406 }
407 else if (type == EINA_VALUE_TYPE_FLOAT)
408 {
409 float *tmem = (float *) mem;
410 *tmem = va_arg(args, double); /* promoted by va_arg */
411 return EINA_TRUE;
412 }
413 else if (type == EINA_VALUE_TYPE_DOUBLE)
414 {
415 double *tmem = (double *) mem;
416 *tmem = va_arg(args, double);
417 return EINA_TRUE;
418 }
419 else if (type == EINA_VALUE_TYPE_STRINGSHARE)
420 {
421 const char *str = (const char *) va_arg(args, const char *);
422 return eina_stringshare_replace((const char **)&value->value.ptr, str);
423 }
424 else if (type == EINA_VALUE_TYPE_STRING)
425 {
426 const char *str = (const char *) va_arg(args, const char *);
427 if (value->value.ptr == str) return EINA_TRUE;
428 if (!str)
429 {
430 free(value->value.ptr);
431 value->value.ptr = NULL;
432 }
433 else
434 {
435 char *tmp = strdup(str);
436 if (!tmp) return EINA_FALSE;
437 free(value->value.ptr);
438 value->value.ptr = tmp;
439 }
440 return EINA_TRUE;
441 }
442 #endif
443
444 va_copy(args_copy, args);
445 if (type->vset) r = type->vset(type, mem, args_copy);
446 va_end(args_copy);
447
448 return r;
449 }
450
451 static inline Eina_Bool
eina_value_vget(const Eina_Value * value,va_list args)452 eina_value_vget(const Eina_Value *value, va_list args)
453 {
454 const Eina_Value_Type *type;
455 const void *mem;
456 void *ptr;
457
458 EINA_VALUE_TYPE_CHECK_RETURN_VAL(value, EINA_FALSE);
459
460 type = value->type;
461 mem = eina_value_memory_get(value);
462 ptr = va_arg(args, void *);
463 if (EINA_VALUE_TYPE_DEFAULT(type))
464 {
465 memcpy(ptr, mem, type->value_size);
466 return EINA_TRUE;
467 }
468
469 EINA_VALUE_TYPE_DISPATCH_RETURN(value, pget, 0,
470 EINA_FALSE, mem, ptr);
471 }
472
473 static inline Eina_Bool
eina_value_pset(Eina_Value * value,const void * ptr)474 eina_value_pset(Eina_Value *value, const void *ptr)
475 {
476 const Eina_Value_Type *type;
477 void *mem;
478
479 EINA_VALUE_TYPE_CHECK_RETURN_VAL(value, EINA_FALSE);
480 EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_FALSE);
481
482 type = value->type;
483 mem = eina_value_memory_get(value);
484
485 if (EINA_VALUE_TYPE_DEFAULT(type))
486 {
487 if (type == EINA_VALUE_TYPE_STRINGSHARE)
488 {
489 const char *str = *((const char * const *) ptr);
490
491 return eina_stringshare_replace((const char **)&value->value.ptr,
492 str);
493 }
494 else if (type == EINA_VALUE_TYPE_STRING)
495 {
496 const char *str = *((const char * const *) ptr);
497 if (value->value.ptr == str) return EINA_TRUE;
498 if (!str)
499 {
500 free(value->value.ptr);
501 value->value.ptr = NULL;
502 }
503 else
504 {
505 char *tmp = strdup(str);
506 if (!tmp) return EINA_FALSE;
507 free(value->value.ptr);
508 value->value.ptr = tmp;
509 }
510 return EINA_TRUE;
511 }
512 else
513 memcpy(mem, ptr, type->value_size);
514 return EINA_TRUE;
515 }
516
517 EINA_VALUE_TYPE_DISPATCH_RETURN(value, pset, 0,
518 EINA_FALSE, mem, ptr);
519 }
520
521 static inline Eina_Bool
eina_value_pget(const Eina_Value * value,void * ptr)522 eina_value_pget(const Eina_Value *value, void *ptr)
523 {
524 const Eina_Value_Type *type;
525 const void *mem;
526
527 EINA_VALUE_TYPE_CHECK_RETURN_VAL(value, EINA_FALSE);
528 EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_FALSE);
529
530 type = value->type;
531 mem = eina_value_memory_get(value);
532 if (EINA_VALUE_TYPE_DEFAULT(type))
533 {
534 memcpy(ptr, mem, type->value_size);
535 return EINA_TRUE;
536 }
537
538 EINA_VALUE_TYPE_DISPATCH_RETURN(value, pget, 0,
539 EINA_FALSE, mem, ptr);
540 }
541
542 static inline const Eina_Value_Type *
eina_value_type_get(const Eina_Value * value)543 eina_value_type_get(const Eina_Value *value)
544 {
545 EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
546 // Trigger warning if the type is NULL, but the value is != EINA_VALUE_EMTPY.
547 if (!value->type &&
548 value->value._guarantee)
549 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(value->type), NULL);
550 return value->type;
551 }
552
553 #define EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, retval) \
554 EINA_SAFETY_ON_NULL_RETURN_VAL(value, retval); \
555 EINA_SAFETY_ON_FALSE_RETURN_VAL(value->type == EINA_VALUE_TYPE_ARRAY, retval)
556
557 static inline Eina_Bool
eina_value_array_setup(Eina_Value * value,const Eina_Value_Type * subtype,unsigned int step)558 eina_value_array_setup(Eina_Value *value, const Eina_Value_Type *subtype, unsigned int step)
559 {
560 Eina_Value_Array desc = { subtype, step, NULL };
561 if (!eina_value_setup(value, EINA_VALUE_TYPE_ARRAY))
562 return EINA_FALSE;
563 if (!eina_value_pset(value, &desc))
564 {
565 eina_value_flush(value);
566 return EINA_FALSE;
567 }
568 return EINA_TRUE;
569 }
570
571 static inline unsigned int
eina_value_array_count(const Eina_Value * value)572 eina_value_array_count(const Eina_Value *value)
573 {
574 Eina_Value_Array desc;
575 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
576 if (!eina_value_pget(value, &desc))
577 return 0;
578 return desc.array ? eina_inarray_count(desc.array) : 0;
579 }
580
581 static inline Eina_Bool
eina_value_array_remove(Eina_Value * value,unsigned int position)582 eina_value_array_remove(Eina_Value *value, unsigned int position)
583 {
584 Eina_Value_Array desc;
585 void *mem;
586
587 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
588 if (!eina_value_pget(value, &desc))
589 return EINA_FALSE;
590
591 mem = eina_inarray_nth(desc.array, position);
592 if (!mem)
593 return EINA_FALSE;
594
595 eina_value_type_flush(desc.subtype, mem);
596 return eina_inarray_remove_at(desc.array, position);
597 }
598
599 static inline Eina_Bool
eina_value_array_vset(Eina_Value * value,unsigned int position,va_list args)600 eina_value_array_vset(Eina_Value *value, unsigned int position, va_list args)
601 {
602 Eina_Value_Array desc;
603 void *mem;
604
605 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
606 if (!eina_value_pget(value, &desc))
607 return EINA_FALSE;
608
609 mem = eina_inarray_nth(desc.array, position);
610 if (!mem)
611 return EINA_FALSE;
612
613 return eina_value_type_vset(desc.subtype, mem, args);
614 }
615
616 static inline Eina_Bool
eina_value_array_vget(const Eina_Value * value,unsigned int position,va_list args)617 eina_value_array_vget(const Eina_Value *value, unsigned int position, va_list args)
618 {
619 Eina_Value_Array desc;
620 const void *mem;
621 void *ptr;
622 Eina_Bool ret;
623
624 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
625 if (!eina_value_pget(value, &desc))
626 return EINA_FALSE;
627
628 if (position >= eina_inarray_count(desc.array))
629 return EINA_FALSE;
630
631 mem = eina_inarray_nth(desc.array, position);
632 if (!mem)
633 return EINA_FALSE;
634
635 ptr = va_arg(args, void *);
636 ret = eina_value_type_pget(desc.subtype, mem, ptr);
637 return ret;
638 }
639
640 static inline Eina_Bool
eina_value_array_vinsert(Eina_Value * value,unsigned int position,va_list args)641 eina_value_array_vinsert(Eina_Value *value, unsigned int position, va_list args)
642 {
643 Eina_Value_Array desc;
644 void *mem;
645
646 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
647 if (!eina_value_pget(value, &desc))
648 return EINA_FALSE;
649
650 mem = eina_inarray_alloc_at(desc.array, position, 1);
651 if (!mem)
652 return EINA_FALSE;
653
654 if (!eina_value_type_setup(desc.subtype, mem)) goto error_setup;
655 if (!eina_value_type_vset(desc.subtype, mem, args)) goto error_set;
656 return EINA_TRUE;
657
658 error_set:
659 eina_value_type_flush(desc.subtype, mem);
660 error_setup:
661 eina_inarray_remove_at(desc.array, position);
662 return EINA_FALSE;
663 }
664
665 static inline Eina_Bool
eina_value_array_vappend(Eina_Value * value,va_list args)666 eina_value_array_vappend(Eina_Value *value, va_list args)
667 {
668 Eina_Value_Array desc;
669 void *mem;
670 int position;
671
672 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
673 if (!eina_value_pget(value, &desc))
674 return EINA_FALSE;
675
676 position = eina_inarray_count(desc.array);
677 mem = eina_inarray_alloc_at(desc.array, position, 1);
678 if (!mem)
679 return EINA_FALSE;
680
681 if (!eina_value_type_setup(desc.subtype, mem)) goto error_setup;
682 if (!eina_value_type_vset(desc.subtype, mem, args)) goto error_set;
683 return EINA_TRUE;
684
685 error_set:
686 eina_value_type_flush(desc.subtype, mem);
687 error_setup:
688 eina_inarray_remove_at(desc.array, position);
689 return EINA_FALSE;
690 }
691
692 static inline Eina_Bool
eina_value_array_set(Eina_Value * value,unsigned int position,...)693 eina_value_array_set(Eina_Value *value, unsigned int position, ...)
694 {
695 va_list args;
696 Eina_Bool ret;
697 va_start(args, position);
698 ret = eina_value_array_vset(value, position, args);
699 va_end(args);
700 return ret;
701 }
702
703 static inline Eina_Bool
eina_value_array_get(const Eina_Value * value,unsigned int position,...)704 eina_value_array_get(const Eina_Value *value, unsigned int position, ...)
705 {
706 va_list args;
707 Eina_Bool ret;
708 va_start(args, position);
709 ret = eina_value_array_vget(value, position, args);
710 va_end(args);
711 return ret;
712 }
713
714 static inline Eina_Bool
eina_value_array_insert(Eina_Value * value,unsigned int position,...)715 eina_value_array_insert(Eina_Value *value, unsigned int position, ...)
716 {
717 va_list args;
718 Eina_Bool ret;
719 va_start(args, position);
720 ret = eina_value_array_vinsert(value, position, args);
721 va_end(args);
722 return ret;
723 }
724
eina_value_array_append(Eina_Value * value,...)725 static inline Eina_Bool eina_value_array_append(Eina_Value *value, ...)
726 {
727 va_list args;
728 Eina_Bool ret;
729 va_start(args, value);
730 ret = eina_value_array_vappend(value, args);
731 va_end(args);
732 return ret;
733 }
734
735 static inline Eina_Bool
eina_value_array_pset(Eina_Value * value,unsigned int position,const void * ptr)736 eina_value_array_pset(Eina_Value *value, unsigned int position, const void *ptr)
737 {
738 Eina_Value_Array desc;
739 void *mem;
740
741 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
742 if (!eina_value_pget(value, &desc))
743 return EINA_FALSE;
744
745 mem = eina_inarray_nth(desc.array, position);
746 if (!mem)
747 return EINA_FALSE;
748
749 return eina_value_type_pset(desc.subtype, mem, ptr);
750 }
751
752 static inline Eina_Bool
eina_value_array_pget(const Eina_Value * value,unsigned int position,void * ptr)753 eina_value_array_pget(const Eina_Value *value, unsigned int position, void *ptr)
754 {
755 Eina_Value_Array desc;
756 const void *mem;
757 Eina_Bool ret;
758
759 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
760 if (!eina_value_pget(value, &desc))
761 return EINA_FALSE;
762
763 mem = eina_inarray_nth(desc.array, position);
764 if (!mem)
765 return EINA_FALSE;
766
767 ret = eina_value_type_pget(desc.subtype, mem, ptr);
768 return ret;
769 }
770
771 static inline Eina_Bool
eina_value_array_pinsert(Eina_Value * value,unsigned int position,const void * ptr)772 eina_value_array_pinsert(Eina_Value *value, unsigned int position, const void *ptr)
773 {
774 Eina_Value_Array desc;
775 void *mem;
776
777 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
778 if (!eina_value_pget(value, &desc))
779 return EINA_FALSE;
780
781 mem = eina_inarray_alloc_at(desc.array, position, 1);
782 if (!mem)
783 return EINA_FALSE;
784
785 if (!eina_value_type_setup(desc.subtype, mem)) goto error_setup;
786 if (!eina_value_type_pset(desc.subtype, mem, ptr)) goto error_set;
787 return EINA_TRUE;
788
789 error_set:
790 eina_value_type_flush(desc.subtype, mem);
791 error_setup:
792 eina_inarray_remove_at(desc.array, position);
793 return EINA_FALSE;
794 }
795
796 static inline Eina_Bool
eina_value_array_pappend(Eina_Value * value,const void * ptr)797 eina_value_array_pappend(Eina_Value *value, const void *ptr)
798 {
799 Eina_Value_Array desc;
800 void *mem;
801 int position;
802
803 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(value, 0);
804 if (!eina_value_pget(value, &desc))
805 return EINA_FALSE;
806
807 position = eina_inarray_count(desc.array);
808 mem = eina_inarray_alloc_at(desc.array, position, 1);
809 if (!mem)
810 return EINA_FALSE;
811
812 if (!eina_value_type_setup(desc.subtype, mem)) goto error_setup;
813 if (!eina_value_type_pset(desc.subtype, mem, ptr)) goto error_set;
814 return EINA_TRUE;
815
816 error_set:
817 eina_value_type_flush(desc.subtype, mem);
818 error_setup:
819 eina_inarray_remove_at(desc.array, position);
820 return EINA_FALSE;
821 }
822
823 static inline Eina_Bool
eina_value_array_value_get(const Eina_Value * src,unsigned int position,Eina_Value * dst)824 eina_value_array_value_get(const Eina_Value *src, unsigned int position, Eina_Value *dst)
825 {
826 Eina_Value_Array desc;
827
828 EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL(src, EINA_FALSE);
829 EINA_SAFETY_ON_NULL_RETURN_VAL(dst, EINA_FALSE);
830
831 if (!eina_value_pget(src, &desc))
832 return EINA_FALSE;
833 if (position >= eina_inarray_count(desc.array))
834 return EINA_FALSE;
835 if (!eina_value_setup(dst, desc.subtype))
836 return EINA_FALSE;
837 if (!eina_value_pset(dst, eina_inarray_nth(desc.array, position)))
838 {
839 eina_value_flush(dst);
840 return EINA_FALSE;
841 }
842
843 return EINA_TRUE;
844 }
845
846 #undef EINA_VALUE_TYPE_ARRAY_CHECK_RETURN_VAL
847
848 #define EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, retval) \
849 EINA_SAFETY_ON_NULL_RETURN_VAL(value, retval); \
850 EINA_SAFETY_ON_FALSE_RETURN_VAL(value->type == EINA_VALUE_TYPE_LIST, retval)
851
852 static inline void *
eina_value_list_node_memory_get(const Eina_Value_Type * type,const Eina_List * node)853 eina_value_list_node_memory_get(const Eina_Value_Type *type, const Eina_List *node)
854 {
855 if (node == NULL || type == NULL) return NULL;
856 if (type->value_size <= sizeof(void*))
857 return (void *)&(node->data);
858 return node->data;
859 }
860
861 static inline void *
eina_value_list_node_memory_setup(const Eina_Value_Type * type,Eina_List * node)862 eina_value_list_node_memory_setup(const Eina_Value_Type *type, Eina_List *node)
863 {
864 if (type->value_size <= sizeof(void*))
865 return (void *)&(node->data);
866 node->data = malloc(type->value_size);
867 return node->data;
868 }
869
870 static inline void
eina_value_list_node_memory_flush(const Eina_Value_Type * type,Eina_List * node)871 eina_value_list_node_memory_flush(const Eina_Value_Type *type, Eina_List *node)
872 {
873 if (type->value_size <= sizeof(void*))
874 return;
875 if (node->data != (void*)1L) free(node->data);
876 }
877
878 static inline Eina_Bool
eina_value_list_setup(Eina_Value * value,const Eina_Value_Type * subtype)879 eina_value_list_setup(Eina_Value *value, const Eina_Value_Type *subtype)
880 {
881 Eina_Value_List desc = { subtype, NULL };
882 if (!eina_value_setup(value, EINA_VALUE_TYPE_LIST))
883 return EINA_FALSE;
884 if (!eina_value_pset(value, &desc))
885 {
886 eina_value_flush(value);
887 return EINA_FALSE;
888 }
889 return EINA_TRUE;
890 }
891
892 static inline unsigned int
eina_value_list_count(const Eina_Value * value)893 eina_value_list_count(const Eina_Value *value)
894 {
895 Eina_Value_List *desc;
896 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
897 desc = (Eina_Value_List *)eina_value_memory_get(value);
898 if (!desc)
899 return 0;
900 return eina_list_count(desc->list);
901 }
902
903 static inline Eina_Bool
eina_value_list_remove(Eina_Value * value,unsigned int position)904 eina_value_list_remove(Eina_Value *value, unsigned int position)
905 {
906 Eina_Value_List *desc;
907 Eina_List *node;
908 void *mem;
909
910 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
911 desc = (Eina_Value_List *)eina_value_memory_get(value);
912 if (!desc)
913 return EINA_FALSE;
914
915 node = eina_list_nth_list(desc->list, position);
916 mem = eina_value_list_node_memory_get(desc->subtype, node);
917 if (!mem)
918 return EINA_FALSE;
919
920 eina_value_type_flush(desc->subtype, mem);
921 eina_value_list_node_memory_flush(desc->subtype, node);
922 desc->list = eina_list_remove_list(desc->list, node);
923 return EINA_TRUE;
924 }
925
926 static inline Eina_Bool
eina_value_list_vset(Eina_Value * value,unsigned int position,va_list args)927 eina_value_list_vset(Eina_Value *value, unsigned int position, va_list args)
928 {
929 Eina_Value_List *desc;
930 Eina_List *node;
931 void *mem;
932
933 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
934 desc = (Eina_Value_List *)eina_value_memory_get(value);
935 if (!desc)
936 return EINA_FALSE;
937
938 node = eina_list_nth_list(desc->list, position);
939 mem = eina_value_list_node_memory_get(desc->subtype, node);
940 if (!mem)
941 return EINA_FALSE;
942
943 return eina_value_type_vset(desc->subtype, mem, args);
944 }
945
946 static inline Eina_Bool
eina_value_list_vget(const Eina_Value * value,unsigned int position,va_list args)947 eina_value_list_vget(const Eina_Value *value, unsigned int position, va_list args)
948 {
949 const Eina_Value_List *desc;
950 const Eina_List *node;
951 const void *mem;
952 void *ptr;
953 Eina_Bool ret;
954
955 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
956 desc = (const Eina_Value_List *)eina_value_memory_get(value);
957 if (!desc)
958 return EINA_FALSE;
959
960 node = eina_list_nth_list(desc->list, position);
961 mem = eina_value_list_node_memory_get(desc->subtype, node);
962 if (!mem)
963 return EINA_FALSE;
964
965 ptr = va_arg(args, void *);
966 ret = eina_value_type_pget(desc->subtype, mem, ptr);
967 return ret;
968 }
969
970 static inline Eina_Bool
eina_value_list_vinsert(Eina_Value * value,unsigned int position,va_list args)971 eina_value_list_vinsert(Eina_Value *value, unsigned int position, va_list args)
972 {
973 Eina_Value_List *desc;
974 Eina_List *node;
975 void *mem;
976
977 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
978 desc = (Eina_Value_List *)eina_value_memory_get(value);
979 if (!desc)
980 return EINA_FALSE;
981
982 if (!desc->list && position == 0)
983 node = desc->list = eina_list_append(NULL, (void*)1L);
984 else if (position == 0)
985 node = desc->list = eina_list_prepend(desc->list, (void*)1L);
986 else
987 {
988 Eina_List *rel = eina_list_nth_list(desc->list, position - 1);
989 EINA_SAFETY_ON_FALSE_RETURN_VAL(rel, EINA_FALSE);
990 desc->list = eina_list_append_relative_list(desc->list, (void*)1L, rel);
991 node = rel->next;
992 }
993 EINA_SAFETY_ON_NULL_RETURN_VAL(node, EINA_FALSE);
994 EINA_SAFETY_ON_FALSE_RETURN_VAL(node->data == (void*)1L, EINA_FALSE);
995
996 mem = eina_value_list_node_memory_setup(desc->subtype, node);
997 if (!mem)
998 {
999 desc->list = eina_list_remove_list(desc->list, node);
1000 return EINA_FALSE;
1001 }
1002
1003 if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
1004 if (!eina_value_type_vset(desc->subtype, mem, args)) goto error_set;
1005 return EINA_TRUE;
1006
1007 error_set:
1008 eina_value_type_flush(desc->subtype, mem);
1009 error_setup:
1010 eina_value_list_node_memory_flush(desc->subtype, node);
1011 desc->list = eina_list_remove_list(desc->list, node);
1012 return EINA_FALSE;
1013 }
1014
1015 static inline Eina_Bool
eina_value_list_vappend(Eina_Value * value,va_list args)1016 eina_value_list_vappend(Eina_Value *value, va_list args)
1017 {
1018 Eina_Value_List *desc;
1019 Eina_List *node;
1020 void *mem;
1021
1022 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
1023 desc = (Eina_Value_List *)eina_value_memory_get(value);
1024 if (!desc)
1025 return EINA_FALSE;
1026
1027 desc->list = eina_list_append(desc->list, (void*)1L);
1028 node = eina_list_last(desc->list);
1029 EINA_SAFETY_ON_NULL_RETURN_VAL(node, EINA_FALSE);
1030 EINA_SAFETY_ON_FALSE_RETURN_VAL(node->data == (void*)1L, EINA_FALSE);
1031
1032 mem = eina_value_list_node_memory_setup(desc->subtype, node);
1033 if (!mem)
1034 {
1035 desc->list = eina_list_remove_list(desc->list, node);
1036 return EINA_FALSE;
1037 }
1038
1039 if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
1040 if (!eina_value_type_vset(desc->subtype, mem, args)) goto error_set;
1041 return EINA_TRUE;
1042
1043 error_set:
1044 eina_value_type_flush(desc->subtype, mem);
1045 error_setup:
1046 eina_value_list_node_memory_flush(desc->subtype, node);
1047 desc->list = eina_list_remove_list(desc->list, node);
1048 return EINA_FALSE;
1049 }
1050
1051 static inline Eina_Bool
eina_value_list_set(Eina_Value * value,unsigned int position,...)1052 eina_value_list_set(Eina_Value *value, unsigned int position, ...)
1053 {
1054 va_list args;
1055 Eina_Bool ret;
1056 va_start(args, position);
1057 ret = eina_value_list_vset(value, position, args);
1058 va_end(args);
1059 return ret;
1060 }
1061
1062 static inline Eina_Bool
eina_value_list_get(const Eina_Value * value,unsigned int position,...)1063 eina_value_list_get(const Eina_Value *value, unsigned int position, ...)
1064 {
1065 va_list args;
1066 Eina_Bool ret;
1067 va_start(args, position);
1068 ret = eina_value_list_vget(value, position, args);
1069 va_end(args);
1070 return ret;
1071 }
1072
1073 static inline Eina_Bool
eina_value_list_insert(Eina_Value * value,unsigned int position,...)1074 eina_value_list_insert(Eina_Value *value, unsigned int position, ...)
1075 {
1076 va_list args;
1077 Eina_Bool ret;
1078 va_start(args, position);
1079 ret = eina_value_list_vinsert(value, position, args);
1080 va_end(args);
1081 return ret;
1082 }
1083
eina_value_list_append(Eina_Value * value,...)1084 static inline Eina_Bool eina_value_list_append(Eina_Value *value, ...)
1085 {
1086 va_list args;
1087 Eina_Bool ret;
1088 va_start(args, value);
1089 ret = eina_value_list_vappend(value, args);
1090 va_end(args);
1091 return ret;
1092 }
1093
1094 static inline Eina_Bool
eina_value_list_pset(Eina_Value * value,unsigned int position,const void * ptr)1095 eina_value_list_pset(Eina_Value *value, unsigned int position, const void *ptr)
1096 {
1097 Eina_Value_List *desc;
1098 Eina_List *node;
1099 void *mem;
1100
1101 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
1102 desc = (Eina_Value_List *)eina_value_memory_get(value);
1103 if (!desc)
1104 return EINA_FALSE;
1105
1106 node = eina_list_nth_list(desc->list, position);
1107 mem = eina_value_list_node_memory_get(desc->subtype, node);
1108 if (!mem)
1109 return EINA_FALSE;
1110
1111 return eina_value_type_pset(desc->subtype, mem, ptr);
1112 }
1113
1114 static inline Eina_Bool
eina_value_list_pget(const Eina_Value * value,unsigned int position,void * ptr)1115 eina_value_list_pget(const Eina_Value *value, unsigned int position, void *ptr)
1116 {
1117 const Eina_Value_List *desc;
1118 const Eina_List *node;
1119 const void *mem;
1120 Eina_Bool ret;
1121
1122 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
1123 desc = (const Eina_Value_List *)eina_value_memory_get(value);
1124 if (!desc)
1125 return EINA_FALSE;
1126
1127 node = eina_list_nth_list(desc->list, position);
1128 mem = eina_value_list_node_memory_get(desc->subtype, node);
1129 if (!mem)
1130 return EINA_FALSE;
1131
1132 ret = eina_value_type_pget(desc->subtype, mem, ptr);
1133 return ret;
1134 }
1135
1136 static inline Eina_Bool
eina_value_list_pinsert(Eina_Value * value,unsigned int position,const void * ptr)1137 eina_value_list_pinsert(Eina_Value *value, unsigned int position, const void *ptr)
1138 {
1139 Eina_Value_List *desc;
1140 Eina_List *node;
1141 void *mem;
1142
1143 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
1144 desc = (Eina_Value_List *)eina_value_memory_get(value);
1145 if (!desc)
1146 return EINA_FALSE;
1147
1148 if (!desc->list)
1149 node = desc->list = eina_list_append(NULL, (void*)1L);
1150 else if (position == 0)
1151 node = desc->list = eina_list_prepend(desc->list, (void*)1L);
1152 else
1153 {
1154 Eina_List *rel = eina_list_nth_list(desc->list, position - 1);
1155 desc->list = eina_list_append_relative_list(desc->list, (void*)1L, rel);
1156 node = rel->next;
1157 }
1158 EINA_SAFETY_ON_NULL_RETURN_VAL(node, EINA_FALSE);
1159 EINA_SAFETY_ON_FALSE_RETURN_VAL(node->data == (void*)1L, EINA_FALSE);
1160
1161 mem = eina_value_list_node_memory_setup(desc->subtype, node);
1162 if (!mem)
1163 {
1164 desc->list = eina_list_remove_list(desc->list, node);
1165 return EINA_FALSE;
1166 }
1167
1168 if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
1169 if (!eina_value_type_pset(desc->subtype, mem, ptr)) goto error_set;
1170 return EINA_TRUE;
1171
1172 error_set:
1173 eina_value_type_flush(desc->subtype, mem);
1174 error_setup:
1175 eina_value_list_node_memory_flush(desc->subtype, node);
1176 desc->list = eina_list_remove_list(desc->list, node);
1177 return EINA_FALSE;
1178 }
1179
1180 static inline Eina_Bool
eina_value_list_pappend(Eina_Value * value,const void * ptr)1181 eina_value_list_pappend(Eina_Value *value, const void *ptr)
1182 {
1183 Eina_Value_List *desc;
1184 Eina_List *node;
1185 void *mem;
1186
1187 EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL(value, 0);
1188 desc = (Eina_Value_List *)eina_value_memory_get(value);
1189 if (!desc)
1190 return EINA_FALSE;
1191
1192 desc->list = eina_list_append(desc->list, (void*)1L);
1193 node = eina_list_last(desc->list);
1194 EINA_SAFETY_ON_NULL_RETURN_VAL(node, EINA_FALSE);
1195 EINA_SAFETY_ON_FALSE_RETURN_VAL(node->data == (void*)1L, EINA_FALSE);
1196
1197 mem = eina_value_list_node_memory_setup(desc->subtype, node);
1198 if (!mem)
1199 {
1200 desc->list = eina_list_remove_list(desc->list, node);
1201 return EINA_FALSE;
1202 }
1203
1204 if (!eina_value_type_setup(desc->subtype, mem)) goto error_setup;
1205 if (!eina_value_type_pset(desc->subtype, mem, ptr)) goto error_set;
1206 return EINA_TRUE;
1207
1208 error_set:
1209 eina_value_type_flush(desc->subtype, mem);
1210 error_setup:
1211 eina_value_list_node_memory_flush(desc->subtype, node);
1212 desc->list = eina_list_remove_list(desc->list, node);
1213 return EINA_FALSE;
1214 }
1215 #undef EINA_VALUE_TYPE_LIST_CHECK_RETURN_VAL
1216
1217 #define EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, retval) \
1218 EINA_SAFETY_ON_NULL_RETURN_VAL(value, retval); \
1219 EINA_SAFETY_ON_FALSE_RETURN_VAL(value->type == EINA_VALUE_TYPE_HASH, retval)
1220
1221 static inline Eina_Bool
eina_value_hash_setup(Eina_Value * value,const Eina_Value_Type * subtype,unsigned int buckets_power_size)1222 eina_value_hash_setup(Eina_Value *value, const Eina_Value_Type *subtype, unsigned int buckets_power_size)
1223 {
1224 Eina_Value_Hash desc = { subtype, buckets_power_size, NULL };
1225 if (!eina_value_setup(value, EINA_VALUE_TYPE_HASH))
1226 return EINA_FALSE;
1227 if (!eina_value_pset(value, &desc))
1228 {
1229 eina_value_flush(value);
1230 return EINA_FALSE;
1231 }
1232 return EINA_TRUE;
1233 }
1234
1235 static inline unsigned int
eina_value_hash_population(const Eina_Value * value)1236 eina_value_hash_population(const Eina_Value *value)
1237 {
1238 Eina_Value_Hash *desc;
1239 EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, 0);
1240 desc = (Eina_Value_Hash *)eina_value_memory_get(value);
1241 if (!desc)
1242 return 0;
1243 return eina_hash_population(desc->hash);
1244 }
1245
1246 static inline Eina_Bool
eina_value_hash_del(Eina_Value * value,const char * key)1247 eina_value_hash_del(Eina_Value *value, const char *key)
1248 {
1249 Eina_Value_Hash *desc;
1250 void *mem;
1251
1252 EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, EINA_FALSE);
1253 EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
1254 desc = (Eina_Value_Hash *)eina_value_memory_get(value);
1255 if (!desc)
1256 return EINA_FALSE;
1257
1258 mem = eina_hash_find(desc->hash, key);
1259 if (!mem)
1260 return EINA_FALSE;
1261
1262 eina_value_type_flush(desc->subtype, mem);
1263 free(mem);
1264 eina_hash_del_by_key(desc->hash, key);
1265 return EINA_TRUE;
1266 }
1267
1268 static inline Eina_Bool
eina_value_hash_vset(Eina_Value * value,const char * key,va_list args)1269 eina_value_hash_vset(Eina_Value *value, const char *key, va_list args)
1270 {
1271 Eina_Value_Hash *desc;
1272 void *mem;
1273
1274 EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, EINA_FALSE);
1275 EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
1276 desc = (Eina_Value_Hash *)eina_value_memory_get(value);
1277 if (!desc)
1278 return EINA_FALSE;
1279
1280 mem = eina_hash_find(desc->hash, key);
1281 if (!mem)
1282 {
1283 mem = malloc(desc->subtype->value_size);
1284 if (!mem) return EINA_FALSE;
1285 if (!eina_hash_add(desc->hash, key, mem))
1286 {
1287 free(mem);
1288 return EINA_FALSE;
1289 }
1290 if (!eina_value_type_setup(desc->subtype, mem))
1291 {
1292 eina_value_type_flush(desc->subtype, mem);
1293 eina_hash_del_by_key(desc->hash, key);
1294 free(mem);
1295 return EINA_FALSE;
1296 }
1297 }
1298
1299 return eina_value_type_vset(desc->subtype, mem, args);
1300 }
1301
1302 static inline Eina_Bool
eina_value_hash_vget(const Eina_Value * value,const char * key,va_list args)1303 eina_value_hash_vget(const Eina_Value *value, const char *key, va_list args)
1304 {
1305 const Eina_Value_Hash *desc;
1306 const void *mem;
1307 void *ptr;
1308 Eina_Bool ret;
1309
1310 EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, EINA_FALSE);
1311 EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
1312 desc = (const Eina_Value_Hash *)eina_value_memory_get(value);
1313 if (!desc)
1314 return EINA_FALSE;
1315
1316 mem = eina_hash_find(desc->hash, key);
1317 if (!mem)
1318 return EINA_FALSE;
1319
1320 ptr = va_arg(args, void *);
1321 ret = eina_value_type_pget(desc->subtype, mem, ptr);
1322 return ret;
1323 }
1324
1325 static inline Eina_Bool
eina_value_hash_set(Eina_Value * value,const char * key,...)1326 eina_value_hash_set(Eina_Value *value, const char *key, ...)
1327 {
1328 va_list args;
1329 Eina_Bool ret;
1330 va_start(args, key);
1331 ret = eina_value_hash_vset(value, key, args);
1332 va_end(args);
1333 return ret;
1334 }
1335
1336 static inline Eina_Bool
eina_value_hash_get(const Eina_Value * value,const char * key,...)1337 eina_value_hash_get(const Eina_Value *value, const char *key, ...)
1338 {
1339 va_list args;
1340 Eina_Bool ret;
1341 va_start(args, key);
1342 ret = eina_value_hash_vget(value, key, args);
1343 va_end(args);
1344 return ret;
1345 }
1346
1347 static inline Eina_Bool
eina_value_hash_pset(Eina_Value * value,const char * key,const void * ptr)1348 eina_value_hash_pset(Eina_Value *value, const char *key, const void *ptr)
1349 {
1350 Eina_Value_Hash *desc;
1351 void *mem;
1352
1353 EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, 0);
1354 EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
1355 desc = (Eina_Value_Hash *)eina_value_memory_get(value);
1356 if (!desc)
1357 return EINA_FALSE;
1358
1359 mem = eina_hash_find(desc->hash, key);
1360 if (!mem)
1361 {
1362 mem = malloc(desc->subtype->value_size);
1363 if (!mem) return EINA_FALSE;
1364 if (!eina_hash_add(desc->hash, key, mem))
1365 {
1366 free(mem);
1367 return EINA_FALSE;
1368 }
1369 if (!eina_value_type_setup(desc->subtype, mem))
1370 {
1371 eina_value_type_flush(desc->subtype, mem);
1372 eina_hash_del_by_key(desc->hash, key);
1373 free(mem);
1374 return EINA_FALSE;
1375 }
1376 }
1377
1378 return eina_value_type_pset(desc->subtype, mem, ptr);
1379 }
1380
1381 static inline Eina_Bool
eina_value_hash_pget(const Eina_Value * value,const char * key,void * ptr)1382 eina_value_hash_pget(const Eina_Value *value, const char *key, void *ptr)
1383 {
1384 const Eina_Value_Hash *desc;
1385 const void *mem;
1386 Eina_Bool ret;
1387
1388 EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL(value, 0);
1389 EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
1390 desc = (const Eina_Value_Hash *)eina_value_memory_get(value);
1391 if (!desc)
1392 return EINA_FALSE;
1393
1394 mem = eina_hash_find(desc->hash, key);
1395 if (!mem)
1396 return EINA_FALSE;
1397
1398 ret = eina_value_type_pget(desc->subtype, mem, ptr);
1399 return ret;
1400 }
1401 #undef EINA_VALUE_TYPE_HASH_CHECK_RETURN_VAL
1402
1403 #define EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, retval) \
1404 EINA_SAFETY_ON_NULL_RETURN_VAL(value, retval); \
1405 EINA_SAFETY_ON_FALSE_RETURN_VAL(value->type == EINA_VALUE_TYPE_STRUCT, retval)
1406
1407 /**
1408 * @brief Find member of struct
1409 * @since 1.2
1410 * @internal
1411 */
1412 EAPI const Eina_Value_Struct_Member *eina_value_struct_member_find(const Eina_Value_Struct *st, const char *name) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
1413
1414 static inline Eina_Bool
eina_value_struct_setup(Eina_Value * value,const Eina_Value_Struct_Desc * sdesc)1415 eina_value_struct_setup(Eina_Value *value, const Eina_Value_Struct_Desc *sdesc)
1416 {
1417 Eina_Value_Struct desc = {sdesc, NULL};
1418 if (!eina_value_setup(value, EINA_VALUE_TYPE_STRUCT))
1419 return EINA_FALSE;
1420 if (!eina_value_pset(value, &desc))
1421 {
1422 eina_value_flush(value);
1423 return EINA_FALSE;
1424 }
1425 return EINA_TRUE;
1426 }
1427
1428 static inline const Eina_Value_Struct_Desc *
eina_value_struct_desc_get(const Eina_Value * value)1429 eina_value_struct_desc_get(const Eina_Value *value)
1430 {
1431 const Eina_Value_Struct *st;
1432
1433 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, NULL);
1434 st = (const Eina_Value_Struct *)eina_value_memory_get(value);
1435 if ((!st) || (!st->desc))
1436 return NULL;
1437 EINA_SAFETY_ON_FALSE_RETURN_VAL(st->desc->version == EINA_VALUE_STRUCT_DESC_VERSION, NULL);
1438 return st->desc;
1439 }
1440
1441 static inline void *
eina_value_struct_member_memory_get(const Eina_Value_Struct * st,const Eina_Value_Struct_Member * member)1442 eina_value_struct_member_memory_get(const Eina_Value_Struct *st, const Eina_Value_Struct_Member *member)
1443 {
1444 unsigned char *base = (unsigned char *)st->memory;
1445 if (!base) return NULL;
1446 return base + member->offset;
1447 }
1448
1449 static inline Eina_Bool
eina_value_struct_vset(Eina_Value * value,const char * name,va_list args)1450 eina_value_struct_vset(Eina_Value *value, const char *name, va_list args)
1451 {
1452 const Eina_Value_Struct_Member *member;
1453 Eina_Value_Struct *st;
1454 void *mem;
1455
1456 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, EINA_FALSE);
1457 EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1458 st = (Eina_Value_Struct *)eina_value_memory_get(value);
1459 if (!st)
1460 return EINA_FALSE;
1461 member = eina_value_struct_member_find(st, name);
1462 if (!member)
1463 return EINA_FALSE;
1464 mem = eina_value_struct_member_memory_get(st, member);
1465 if (!mem)
1466 return EINA_FALSE;
1467
1468 return eina_value_type_vset(member->type, mem, args);
1469 }
1470
1471 static inline Eina_Bool
eina_value_struct_vget(const Eina_Value * value,const char * name,va_list args)1472 eina_value_struct_vget(const Eina_Value *value, const char *name, va_list args)
1473 {
1474 const Eina_Value_Struct_Member *member;
1475 const Eina_Value_Struct *st;
1476 const void *mem;
1477 void *ptr;
1478 Eina_Bool ret;
1479
1480 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, EINA_FALSE);
1481 EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1482 st = (const Eina_Value_Struct *)eina_value_memory_get(value);
1483 if (!st)
1484 return EINA_FALSE;
1485 member = eina_value_struct_member_find(st, name);
1486 if (!member)
1487 return EINA_FALSE;
1488 mem = eina_value_struct_member_memory_get(st, member);
1489 if (!mem)
1490 return EINA_FALSE;
1491
1492 ptr = va_arg(args, void *);
1493 ret = eina_value_type_pget(member->type, mem, ptr);
1494 return ret;
1495 }
1496
1497 static inline Eina_Bool
eina_value_struct_set(Eina_Value * value,const char * name,...)1498 eina_value_struct_set(Eina_Value *value, const char *name, ...)
1499 {
1500 va_list args;
1501 Eina_Bool ret;
1502 va_start(args, name);
1503 ret = eina_value_struct_vset(value, name, args);
1504 va_end(args);
1505 return ret;
1506 }
1507
1508 static inline Eina_Bool
eina_value_struct_get(const Eina_Value * value,const char * name,...)1509 eina_value_struct_get(const Eina_Value *value, const char *name, ...)
1510 {
1511 va_list args;
1512 Eina_Bool ret;
1513 va_start(args, name);
1514 ret = eina_value_struct_vget(value, name, args);
1515 va_end(args);
1516 return ret;
1517 }
1518
1519 static inline Eina_Bool
eina_value_struct_pset(Eina_Value * value,const char * name,const void * ptr)1520 eina_value_struct_pset(Eina_Value *value, const char *name, const void *ptr)
1521 {
1522 const Eina_Value_Struct_Member *member;
1523 Eina_Value_Struct *st;
1524 void *mem;
1525
1526 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, EINA_FALSE);
1527 EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1528 EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_FALSE);
1529 st = (Eina_Value_Struct *)eina_value_memory_get(value);
1530 if (!st)
1531 return EINA_FALSE;
1532 member = eina_value_struct_member_find(st, name);
1533 if (!member)
1534 return EINA_FALSE;
1535 mem = eina_value_struct_member_memory_get(st, member);
1536 if (!mem)
1537 return EINA_FALSE;
1538
1539 return eina_value_type_pset(member->type, mem, ptr);
1540 }
1541
1542 static inline Eina_Bool
eina_value_struct_pget(const Eina_Value * value,const char * name,void * ptr)1543 eina_value_struct_pget(const Eina_Value *value, const char *name, void *ptr)
1544 {
1545 const Eina_Value_Struct_Member *member;
1546 const Eina_Value_Struct *st;
1547 const void *mem;
1548 Eina_Bool ret;
1549
1550 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(value, EINA_FALSE);
1551 EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1552 EINA_SAFETY_ON_NULL_RETURN_VAL(ptr, EINA_FALSE);
1553 st = (const Eina_Value_Struct *)eina_value_memory_get(value);
1554 if (!st)
1555 return EINA_FALSE;
1556 member = eina_value_struct_member_find(st, name);
1557 if (!member)
1558 return EINA_FALSE;
1559 mem = eina_value_struct_member_memory_get(st, member);
1560 if (!mem)
1561 return EINA_FALSE;
1562
1563 ret = eina_value_type_pget(member->type, mem, ptr);
1564 return ret;
1565 }
1566
1567 static inline Eina_Bool
eina_value_struct_value_get(const Eina_Value * src,const char * name,Eina_Value * dst)1568 eina_value_struct_value_get(const Eina_Value *src, const char *name, Eina_Value *dst)
1569 {
1570 const Eina_Value_Struct_Member *member;
1571 const Eina_Value_Struct *st;
1572 const void *mem;
1573
1574 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(src, EINA_FALSE);
1575 EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1576 EINA_SAFETY_ON_NULL_RETURN_VAL(dst, EINA_FALSE);
1577 st = (const Eina_Value_Struct *)eina_value_memory_get(src);
1578 if (!st)
1579 return EINA_FALSE;
1580 member = eina_value_struct_member_find(st, name);
1581 if (!member)
1582 return EINA_FALSE;
1583 mem = eina_value_struct_member_memory_get(st, member);
1584 if (!mem)
1585 return EINA_FALSE;
1586 if (!eina_value_setup(dst, member->type))
1587 return EINA_FALSE;
1588 if (!eina_value_pset(dst, mem))
1589 {
1590 eina_value_flush(dst);
1591 return EINA_FALSE;
1592 }
1593 return EINA_TRUE;
1594 }
1595
1596 static inline Eina_Bool
eina_value_struct_value_set(Eina_Value * dst,const char * name,const Eina_Value * src)1597 eina_value_struct_value_set(Eina_Value *dst, const char *name, const Eina_Value *src)
1598 {
1599 const Eina_Value_Struct_Member *member;
1600 Eina_Value_Struct *st;
1601 void *mem;
1602 const void *ptr;
1603
1604 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(dst, EINA_FALSE);
1605 EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1606 EINA_SAFETY_ON_NULL_RETURN_VAL(src, EINA_FALSE);
1607
1608 st = (Eina_Value_Struct *)eina_value_memory_get(dst);
1609 if (!st)
1610 return EINA_FALSE;
1611 member = eina_value_struct_member_find(st, name);
1612 if (!member)
1613 return EINA_FALSE;
1614 EINA_SAFETY_ON_FALSE_RETURN_VAL(src->type == member->type, EINA_FALSE);
1615
1616 mem = eina_value_struct_member_memory_get(st, member);
1617 if (!mem)
1618 return EINA_FALSE;
1619
1620 ptr = eina_value_memory_get(src);
1621 if (!ptr)
1622 return EINA_FALSE;
1623
1624 return eina_value_type_pset(member->type, mem, ptr);
1625 }
1626
1627 static inline Eina_Bool
eina_value_struct_member_value_get(const Eina_Value * src,const Eina_Value_Struct_Member * member,Eina_Value * dst)1628 eina_value_struct_member_value_get(const Eina_Value *src, const Eina_Value_Struct_Member *member, Eina_Value *dst)
1629 {
1630 const Eina_Value_Struct *st;
1631 const void *mem;
1632
1633 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(src, EINA_FALSE);
1634 EINA_SAFETY_ON_NULL_RETURN_VAL(member, EINA_FALSE);
1635 EINA_SAFETY_ON_NULL_RETURN_VAL(dst, EINA_FALSE);
1636 st = (const Eina_Value_Struct *)eina_value_memory_get(src);
1637 if (!st)
1638 return EINA_FALSE;
1639 mem = eina_value_struct_member_memory_get(st, member);
1640 if (!mem)
1641 return EINA_FALSE;
1642 if (!eina_value_setup(dst, member->type))
1643 return EINA_FALSE;
1644 if (!eina_value_pset(dst, mem))
1645 {
1646 eina_value_flush(dst);
1647 return EINA_FALSE;
1648 }
1649 return EINA_TRUE;
1650 }
1651
1652 static inline Eina_Bool
eina_value_struct_member_value_set(Eina_Value * dst,const Eina_Value_Struct_Member * member,const Eina_Value * src)1653 eina_value_struct_member_value_set(Eina_Value *dst, const Eina_Value_Struct_Member *member, const Eina_Value *src)
1654 {
1655 Eina_Value_Struct *st;
1656 void *mem;
1657 const void *ptr;
1658
1659 EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL(dst, EINA_FALSE);
1660 EINA_SAFETY_ON_NULL_RETURN_VAL(member, EINA_FALSE);
1661 EINA_SAFETY_ON_NULL_RETURN_VAL(src, EINA_FALSE);
1662
1663 st = (Eina_Value_Struct *)eina_value_memory_get(dst);
1664 if (!st)
1665 return EINA_FALSE;
1666 EINA_SAFETY_ON_FALSE_RETURN_VAL(src->type == member->type, EINA_FALSE);
1667
1668 mem = eina_value_struct_member_memory_get(st, member);
1669 if (!mem)
1670 return EINA_FALSE;
1671
1672 ptr = eina_value_memory_get(src);
1673 if (!ptr)
1674 return EINA_FALSE;
1675
1676 return eina_value_type_pset(member->type, mem, ptr);
1677 }
1678
1679 #undef EINA_VALUE_TYPE_STRUCT_CHECK_RETURN_VAL
1680
1681 #define EINA_VALUE_TYPE_OPTIONAL_CHECK_RETURN_VAL(value, retval) \
1682 EINA_SAFETY_ON_NULL_RETURN_VAL(value, retval); \
1683 EINA_SAFETY_ON_FALSE_RETURN_VAL(value->type->setup == EINA_VALUE_TYPE_OPTIONAL->setup, retval)
1684
1685 static inline Eina_Value*
eina_value_optional_empty_new(void)1686 eina_value_optional_empty_new(void)
1687 {
1688 return eina_value_new(EINA_VALUE_TYPE_OPTIONAL);
1689 }
1690
1691 struct _Eina_Value_Optional_Outer
1692 {
1693 Eina_Value_Type const* subtype;
1694 void* value;
1695 };
1696 typedef struct _Eina_Value_Optional_Outer Eina_Value_Optional_Outer;
1697
1698 struct _Eina_Value_Optional_Inner
1699 {
1700 Eina_Value_Type const* subtype;
1701 char value[];
1702 };
1703 typedef struct _Eina_Value_Optional_Inner Eina_Value_Optional_Inner;
1704
1705 static inline Eina_Bool
eina_value_optional_empty_is(const Eina_Value * value,Eina_Bool * is_empty)1706 eina_value_optional_empty_is(const Eina_Value *value, Eina_Bool *is_empty)
1707 {
1708 void *mem;
1709
1710 EINA_VALUE_TYPE_OPTIONAL_CHECK_RETURN_VAL(value, EINA_FALSE);
1711 EINA_SAFETY_ON_NULL_RETURN_VAL(is_empty, EINA_FALSE);
1712
1713 mem = eina_value_memory_get(value);
1714 if (!mem)
1715 return EINA_FALSE;
1716 if(2*sizeof(void*) <= sizeof(Eina_Value_Union))
1717 {
1718 Eina_Value_Optional_Outer* opt = (Eina_Value_Optional_Outer*)mem;
1719 *is_empty = !opt->subtype;
1720 }
1721 else
1722 {
1723 *is_empty = ! *(void**)mem;
1724 }
1725 return EINA_TRUE;
1726 }
1727
1728 static inline const Eina_Value_Type *
eina_value_optional_type_get(Eina_Value * value)1729 eina_value_optional_type_get(Eina_Value *value)
1730 {
1731 void *mem;
1732
1733 EINA_VALUE_TYPE_OPTIONAL_CHECK_RETURN_VAL(value, (const Eina_Value_Type *)NULL);
1734
1735 mem = eina_value_memory_get(value);
1736 if (!mem)
1737 return NULL;
1738
1739 if(2*sizeof(void*) <= sizeof(Eina_Value_Union))
1740 {
1741 Eina_Value_Optional_Outer* opt = (Eina_Value_Optional_Outer*)mem;
1742 return opt->subtype;
1743 }
1744 else
1745 {
1746 Eina_Value_Optional_Inner* opt = *(Eina_Value_Optional_Inner**)mem;
1747 if(!opt)
1748 return NULL;
1749 return opt->subtype;
1750 }
1751 }
1752 #undef EINA_VALUE_TYPE_OPTIONAL_CHECK_RETURN_VAL
1753
1754 static inline Eina_Bool
eina_value_type_setup(const Eina_Value_Type * type,void * mem)1755 eina_value_type_setup(const Eina_Value_Type *type, void *mem)
1756 {
1757 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1758 if (!type->setup) return EINA_FALSE;
1759 return type->setup(type, mem);
1760 }
1761
1762 static inline Eina_Bool
eina_value_type_flush(const Eina_Value_Type * type,void * mem)1763 eina_value_type_flush(const Eina_Value_Type *type, void *mem)
1764 {
1765 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1766 if (!type->flush) return EINA_FALSE;
1767 return type->flush(type, mem);
1768 }
1769
1770 static inline Eina_Bool
eina_value_type_copy(const Eina_Value_Type * type,const void * src,void * dst)1771 eina_value_type_copy(const Eina_Value_Type *type, const void *src, void *dst)
1772 {
1773 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1774 if (!type->copy) return EINA_FALSE;
1775 return type->copy(type, src, dst);
1776 }
1777
1778 static inline int
eina_value_type_compare(const Eina_Value_Type * type,const void * a,const void * b)1779 eina_value_type_compare(const Eina_Value_Type *type, const void *a, const void *b)
1780 {
1781 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1782 if (!type->compare) return EINA_FALSE;
1783 return type->compare(type, a, b);
1784 }
1785
1786 static inline Eina_Bool
eina_value_type_convert_to(const Eina_Value_Type * type,const Eina_Value_Type * convert,const void * type_mem,void * convert_mem)1787 eina_value_type_convert_to(const Eina_Value_Type *type, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem)
1788 {
1789 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1790 if (!type->convert_to) return EINA_FALSE;
1791 return type->convert_to(type, convert, type_mem, convert_mem);
1792 }
1793
1794 static inline Eina_Bool
eina_value_type_convert_from(const Eina_Value_Type * type,const Eina_Value_Type * convert,void * type_mem,const void * convert_mem)1795 eina_value_type_convert_from(const Eina_Value_Type *type, const Eina_Value_Type *convert, void *type_mem, const void *convert_mem)
1796 {
1797 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1798 if (!type->convert_from) return EINA_FALSE;
1799 return type->convert_from(type, convert, type_mem, convert_mem);
1800 }
1801
1802 static inline Eina_Bool
eina_value_type_vset(const Eina_Value_Type * type,void * mem,va_list args)1803 eina_value_type_vset(const Eina_Value_Type *type, void *mem, va_list args)
1804 {
1805 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1806 if (!type->vset) return EINA_FALSE;
1807 return type->vset(type, mem, args);
1808 }
1809
1810 static inline Eina_Bool
eina_value_type_pset(const Eina_Value_Type * type,void * mem,const void * ptr)1811 eina_value_type_pset(const Eina_Value_Type *type, void *mem, const void *ptr)
1812 {
1813 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1814 if (!type->pset) return EINA_FALSE;
1815 return type->pset(type, mem, ptr);
1816 }
1817
1818 static inline Eina_Bool
eina_value_type_pget(const Eina_Value_Type * type,const void * mem,void * ptr)1819 eina_value_type_pget(const Eina_Value_Type *type, const void *mem, void *ptr)
1820 {
1821 EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), EINA_FALSE);
1822 if (!type->pget) return EINA_FALSE;
1823 return type->pget(type, mem, ptr);
1824 }
1825
1826 #undef EINA_VALUE_TYPE_DEFAULT
1827 #undef EINA_VALUE_TYPE_CHECK_RETURN
1828 #undef EINA_VALUE_TYPE_CHECK_RETURN_VAL
1829 #undef EINA_VALUE_TYPE_DISPATCH
1830 #undef EINA_VALUE_TYPE_DISPATCH_RETURN
1831 #endif
1832