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