diff options
Diffstat (limited to 'libraries/eina/src/lib/eina_value.c')
-rw-r--r-- | libraries/eina/src/lib/eina_value.c | 5309 |
1 files changed, 0 insertions, 5309 deletions
diff --git a/libraries/eina/src/lib/eina_value.c b/libraries/eina/src/lib/eina_value.c deleted file mode 100644 index b8df693..0000000 --- a/libraries/eina/src/lib/eina_value.c +++ /dev/null | |||
@@ -1,5309 +0,0 @@ | |||
1 | /* eina_value.c | ||
2 | |||
3 | Copyright (C) 2001 Christopher Rosendahl <smugg@fatelabs.com> | ||
4 | Nathan Ingersoll <ningerso@d.umn.edu> | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
7 | of this software and associated documentation files (the "Software"), to | ||
8 | deal in the Software without restriction, including without limitation the | ||
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | ||
10 | sell copies of the Software, and to permit persons to whom the Software is | ||
11 | furnished to do so, subject to the following conditions: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in | ||
14 | all copies of the Software and its documentation and acknowledgment shall be | ||
15 | given in the documentation and software packages that this Software was | ||
16 | used. | ||
17 | |||
18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
20 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
21 | THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER | ||
22 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | ||
23 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
24 | |||
25 | */ | ||
26 | |||
27 | #ifdef HAVE_CONFIG_H | ||
28 | # include "config.h" | ||
29 | #endif | ||
30 | |||
31 | #ifdef HAVE_ALLOCA_H | ||
32 | # include <alloca.h> | ||
33 | #elif defined __GNUC__ | ||
34 | # define alloca __builtin_alloca | ||
35 | #elif defined _AIX | ||
36 | # define alloca __alloca | ||
37 | #elif defined _MSC_VER | ||
38 | # include <malloc.h> | ||
39 | # define alloca _alloca | ||
40 | #else | ||
41 | # include <stddef.h> | ||
42 | # ifdef __cplusplus | ||
43 | extern "C" | ||
44 | # endif | ||
45 | void *alloca (size_t); | ||
46 | #endif | ||
47 | |||
48 | #include <stdio.h> /* asprintf() */ | ||
49 | #include <inttypes.h> /* PRId64 and PRIu64 */ | ||
50 | #include <sys/time.h> /* struct timeval */ | ||
51 | |||
52 | #ifdef HAVE_EVIL | ||
53 | # include <Evil.h> | ||
54 | #endif | ||
55 | |||
56 | #include "eina_config.h" | ||
57 | #include "eina_private.h" | ||
58 | #include "eina_error.h" | ||
59 | #include "eina_log.h" | ||
60 | #include "eina_strbuf.h" | ||
61 | #include "eina_mempool.h" | ||
62 | #include "eina_lock.h" | ||
63 | |||
64 | /* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */ | ||
65 | #include "eina_safety_checks.h" | ||
66 | #include "eina_value.h" | ||
67 | #include "eina_model.h" /* uses eina_value.h */ | ||
68 | |||
69 | /*============================================================================* | ||
70 | * Local * | ||
71 | *============================================================================*/ | ||
72 | |||
73 | /** | ||
74 | * @cond LOCAL | ||
75 | */ | ||
76 | |||
77 | static Eina_Mempool *_eina_value_mp = NULL; | ||
78 | static Eina_Hash *_eina_value_inner_mps = NULL; | ||
79 | static Eina_Lock _eina_value_inner_mps_lock; | ||
80 | static char *_eina_value_mp_choice = NULL; | ||
81 | static int _eina_value_log_dom = -1; | ||
82 | |||
83 | #ifdef ERR | ||
84 | #undef ERR | ||
85 | #endif | ||
86 | #define ERR(...) EINA_LOG_DOM_ERR(_eina_value_log_dom, __VA_ARGS__) | ||
87 | |||
88 | #ifdef DBG | ||
89 | #undef DBG | ||
90 | #endif | ||
91 | #define DBG(...) EINA_LOG_DOM_DBG(_eina_value_log_dom, __VA_ARGS__) | ||
92 | |||
93 | static const unsigned char eina_value_uchar_max = 255U; | ||
94 | static const char eina_value_char_max = 127; | ||
95 | static const char eina_value_char_min = -127 - 1; | ||
96 | |||
97 | static const unsigned short eina_value_ushort_max = 65535U; | ||
98 | static const short eina_value_short_max = 32767; | ||
99 | static const short eina_value_short_min = -32767 - 1; | ||
100 | |||
101 | static const unsigned int eina_value_uint_max = 4294967295U; | ||
102 | static const int eina_value_int_max = 2147483647; | ||
103 | static const int eina_value_int_min = -2147483647 - 1; | ||
104 | |||
105 | static const uint64_t eina_value_uint64_max = 18446744073709551615ULL; | ||
106 | static const int64_t eina_value_int64_max = 9223372036854775807LL; | ||
107 | static const int64_t eina_value_int64_min = -9223372036854775807LL - 1LL; | ||
108 | |||
109 | #if __WORDSIZE == 64 | ||
110 | static const unsigned long eina_value_ulong_max = 18446744073709551615ULL; | ||
111 | static const long eina_value_long_max = 9223372036854775807LL; | ||
112 | static const long eina_value_long_min = -9223372036854775807LL - 1LL; | ||
113 | #else | ||
114 | static const unsigned long eina_value_ulong_max = 4294967295U; | ||
115 | static const long eina_value_long_max = 2147483647; | ||
116 | static const long eina_value_long_min = -2147483647 - 1; | ||
117 | #endif | ||
118 | |||
119 | |||
120 | static Eina_Bool | ||
121 | _eina_value_type_uchar_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
122 | { | ||
123 | unsigned char *tmem = mem; | ||
124 | *tmem = 0; | ||
125 | return EINA_TRUE; | ||
126 | } | ||
127 | |||
128 | static Eina_Bool | ||
129 | _eina_value_type_uchar_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
130 | { | ||
131 | return EINA_TRUE; | ||
132 | } | ||
133 | |||
134 | static Eina_Bool | ||
135 | _eina_value_type_uchar_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
136 | { | ||
137 | const unsigned char *s = src; | ||
138 | unsigned char *d = dst; | ||
139 | *d = *s; | ||
140 | return EINA_TRUE; | ||
141 | } | ||
142 | |||
143 | static int | ||
144 | _eina_value_type_uchar_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
145 | { | ||
146 | const unsigned char *ta = a, *tb = b; | ||
147 | if (*ta < *tb) | ||
148 | return -1; | ||
149 | else if (*ta > *tb) | ||
150 | return 1; | ||
151 | return 0; | ||
152 | } | ||
153 | |||
154 | static Eina_Bool | ||
155 | _eina_value_type_uchar_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
156 | { | ||
157 | const unsigned char v = *(const unsigned char *)type_mem; | ||
158 | |||
159 | eina_error_set(0); | ||
160 | |||
161 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
162 | { | ||
163 | unsigned char other_mem = v; | ||
164 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
165 | } | ||
166 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
167 | { | ||
168 | unsigned short other_mem = v; | ||
169 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
170 | } | ||
171 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
172 | { | ||
173 | unsigned int other_mem = v; | ||
174 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
175 | } | ||
176 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
177 | { | ||
178 | unsigned long other_mem = v; | ||
179 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
180 | } | ||
181 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
182 | { | ||
183 | uint64_t other_mem = v; | ||
184 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
185 | } | ||
186 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
187 | { | ||
188 | char other_mem = v; | ||
189 | if (EINA_UNLIKELY(v > (unsigned char)eina_value_char_max)) | ||
190 | return EINA_FALSE; | ||
191 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
192 | } | ||
193 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
194 | { | ||
195 | short other_mem = v; | ||
196 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
197 | } | ||
198 | else if (convert == EINA_VALUE_TYPE_INT) | ||
199 | { | ||
200 | int other_mem = v; | ||
201 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
202 | } | ||
203 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
204 | { | ||
205 | long other_mem = v; | ||
206 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
207 | } | ||
208 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
209 | { | ||
210 | int64_t other_mem = v; | ||
211 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
212 | } | ||
213 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
214 | { | ||
215 | float other_mem = v; | ||
216 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
217 | } | ||
218 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
219 | { | ||
220 | double other_mem = v; | ||
221 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
222 | } | ||
223 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
224 | convert == EINA_VALUE_TYPE_STRING) | ||
225 | { | ||
226 | const char *other_mem; | ||
227 | char buf[64]; | ||
228 | snprintf(buf, sizeof(buf), "%hhu", v); | ||
229 | other_mem = buf; /* required due &buf == buf */ | ||
230 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
231 | } | ||
232 | else | ||
233 | { | ||
234 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
235 | return EINA_FALSE; | ||
236 | } | ||
237 | |||
238 | return EINA_TRUE; | ||
239 | } | ||
240 | |||
241 | static Eina_Bool | ||
242 | _eina_value_type_uchar_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
243 | { | ||
244 | unsigned char *tmem = mem; | ||
245 | *tmem = va_arg(args, unsigned int); /* char is promoted to int for va_arg */ | ||
246 | return EINA_TRUE; | ||
247 | } | ||
248 | |||
249 | static Eina_Bool | ||
250 | _eina_value_type_uchar_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
251 | { | ||
252 | unsigned char *tmem = mem; | ||
253 | const unsigned char *p = ptr; | ||
254 | *tmem = *p; | ||
255 | return EINA_TRUE; | ||
256 | } | ||
257 | |||
258 | static Eina_Bool | ||
259 | _eina_value_type_uchar_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
260 | { | ||
261 | const unsigned char *tmem = mem; | ||
262 | unsigned char *p = ptr; | ||
263 | *p = *tmem; | ||
264 | return EINA_TRUE; | ||
265 | } | ||
266 | |||
267 | static Eina_Bool | ||
268 | _eina_value_type_ushort_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
269 | { | ||
270 | unsigned short *tmem = mem; | ||
271 | *tmem = 0; | ||
272 | return EINA_TRUE; | ||
273 | } | ||
274 | |||
275 | static Eina_Bool | ||
276 | _eina_value_type_ushort_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
277 | { | ||
278 | return EINA_TRUE; | ||
279 | } | ||
280 | |||
281 | static Eina_Bool | ||
282 | _eina_value_type_ushort_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
283 | { | ||
284 | const unsigned short *s = src; | ||
285 | unsigned short *d = dst; | ||
286 | *d = *s; | ||
287 | return EINA_TRUE; | ||
288 | } | ||
289 | |||
290 | static int | ||
291 | _eina_value_type_ushort_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
292 | { | ||
293 | const unsigned short *ta = a, *tb = b; | ||
294 | if (*ta < *tb) | ||
295 | return -1; | ||
296 | else if (*ta > *tb) | ||
297 | return 1; | ||
298 | return 0; | ||
299 | } | ||
300 | |||
301 | static Eina_Bool | ||
302 | _eina_value_type_ushort_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
303 | { | ||
304 | const unsigned short v = *(const unsigned short *)type_mem; | ||
305 | |||
306 | eina_error_set(0); | ||
307 | |||
308 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
309 | { | ||
310 | unsigned char other_mem = v; | ||
311 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
312 | return EINA_FALSE; | ||
313 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
314 | } | ||
315 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
316 | { | ||
317 | unsigned short other_mem = v; | ||
318 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
319 | } | ||
320 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
321 | { | ||
322 | unsigned int other_mem = v; | ||
323 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
324 | } | ||
325 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
326 | { | ||
327 | unsigned long other_mem = v; | ||
328 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
329 | } | ||
330 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
331 | { | ||
332 | uint64_t other_mem = v; | ||
333 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
334 | } | ||
335 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
336 | { | ||
337 | char other_mem = v; | ||
338 | if (EINA_UNLIKELY(v > (unsigned char)eina_value_char_max)) | ||
339 | return EINA_FALSE; | ||
340 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
341 | } | ||
342 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
343 | { | ||
344 | short other_mem = v; | ||
345 | if (EINA_UNLIKELY(v > (unsigned short)eina_value_short_max)) | ||
346 | return EINA_FALSE; | ||
347 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
348 | } | ||
349 | else if (convert == EINA_VALUE_TYPE_INT) | ||
350 | { | ||
351 | int other_mem = v; | ||
352 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
353 | } | ||
354 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
355 | { | ||
356 | long other_mem = v; | ||
357 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
358 | } | ||
359 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
360 | { | ||
361 | int64_t other_mem = v; | ||
362 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
363 | } | ||
364 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
365 | { | ||
366 | float other_mem = v; | ||
367 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
368 | } | ||
369 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
370 | { | ||
371 | double other_mem = v; | ||
372 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
373 | } | ||
374 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
375 | convert == EINA_VALUE_TYPE_STRING) | ||
376 | { | ||
377 | const char *other_mem; | ||
378 | char buf[64]; | ||
379 | snprintf(buf, sizeof(buf), "%hu", v); | ||
380 | other_mem = buf; /* required due &buf == buf */ | ||
381 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
382 | } | ||
383 | else | ||
384 | { | ||
385 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
386 | return EINA_FALSE; | ||
387 | } | ||
388 | |||
389 | return EINA_TRUE; | ||
390 | } | ||
391 | |||
392 | static Eina_Bool | ||
393 | _eina_value_type_ushort_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
394 | { | ||
395 | unsigned short *tmem = mem; | ||
396 | *tmem = va_arg(args, unsigned int); /* short is promoted to int for va_arg */ | ||
397 | return EINA_TRUE; | ||
398 | } | ||
399 | |||
400 | static Eina_Bool | ||
401 | _eina_value_type_ushort_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
402 | { | ||
403 | unsigned short *tmem = mem; | ||
404 | const unsigned short *p = ptr; | ||
405 | *tmem = *p; | ||
406 | return EINA_TRUE; | ||
407 | } | ||
408 | |||
409 | static Eina_Bool | ||
410 | _eina_value_type_ushort_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
411 | { | ||
412 | const unsigned short *tmem = mem; | ||
413 | unsigned short *p = ptr; | ||
414 | *p = *tmem; | ||
415 | return EINA_TRUE; | ||
416 | } | ||
417 | |||
418 | static Eina_Bool | ||
419 | _eina_value_type_uint_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
420 | { | ||
421 | unsigned int *tmem = mem; | ||
422 | *tmem = 0; | ||
423 | return EINA_TRUE; | ||
424 | } | ||
425 | |||
426 | static Eina_Bool | ||
427 | _eina_value_type_uint_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
428 | { | ||
429 | return EINA_TRUE; | ||
430 | } | ||
431 | |||
432 | static Eina_Bool | ||
433 | _eina_value_type_uint_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
434 | { | ||
435 | const unsigned int *s = src; | ||
436 | unsigned int *d = dst; | ||
437 | *d = *s; | ||
438 | return EINA_TRUE; | ||
439 | } | ||
440 | |||
441 | static int | ||
442 | _eina_value_type_uint_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
443 | { | ||
444 | const unsigned int *ta = a, *tb = b; | ||
445 | if (*ta < *tb) | ||
446 | return -1; | ||
447 | else if (*ta > *tb) | ||
448 | return 1; | ||
449 | return 0; | ||
450 | } | ||
451 | |||
452 | static Eina_Bool | ||
453 | _eina_value_type_uint_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
454 | { | ||
455 | const unsigned int v = *(const unsigned int *)type_mem; | ||
456 | |||
457 | eina_error_set(0); | ||
458 | |||
459 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
460 | { | ||
461 | unsigned char other_mem = v; | ||
462 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
463 | return EINA_FALSE; | ||
464 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
465 | } | ||
466 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
467 | { | ||
468 | unsigned short other_mem = v; | ||
469 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
470 | return EINA_FALSE; | ||
471 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
472 | } | ||
473 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
474 | { | ||
475 | unsigned int other_mem = v; | ||
476 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
477 | } | ||
478 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
479 | { | ||
480 | unsigned long other_mem = v; | ||
481 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
482 | } | ||
483 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
484 | { | ||
485 | uint64_t other_mem = v; | ||
486 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
487 | } | ||
488 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
489 | { | ||
490 | char other_mem = v; | ||
491 | if (EINA_UNLIKELY(v > (unsigned char)eina_value_char_max)) | ||
492 | return EINA_FALSE; | ||
493 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
494 | } | ||
495 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
496 | { | ||
497 | short other_mem = v; | ||
498 | if (EINA_UNLIKELY(v > (unsigned short)eina_value_short_max)) | ||
499 | return EINA_FALSE; | ||
500 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
501 | } | ||
502 | else if (convert == EINA_VALUE_TYPE_INT) | ||
503 | { | ||
504 | int other_mem = v; | ||
505 | if (EINA_UNLIKELY(v > (unsigned int)eina_value_int_max)) | ||
506 | return EINA_FALSE; | ||
507 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
508 | } | ||
509 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
510 | { | ||
511 | long other_mem = v; | ||
512 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
513 | } | ||
514 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
515 | { | ||
516 | int64_t other_mem = v; | ||
517 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
518 | } | ||
519 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
520 | { | ||
521 | float other_mem = v; | ||
522 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
523 | } | ||
524 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
525 | { | ||
526 | double other_mem = v; | ||
527 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
528 | } | ||
529 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
530 | convert == EINA_VALUE_TYPE_STRING) | ||
531 | { | ||
532 | const char *other_mem; | ||
533 | char buf[64]; | ||
534 | snprintf(buf, sizeof(buf), "%u", v); | ||
535 | other_mem = buf; /* required due &buf == buf */ | ||
536 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
537 | } | ||
538 | else | ||
539 | { | ||
540 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
541 | return EINA_FALSE; | ||
542 | } | ||
543 | |||
544 | return EINA_TRUE; | ||
545 | } | ||
546 | |||
547 | static Eina_Bool | ||
548 | _eina_value_type_uint_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
549 | { | ||
550 | unsigned int *tmem = mem; | ||
551 | *tmem = va_arg(args, unsigned int); | ||
552 | return EINA_TRUE; | ||
553 | } | ||
554 | |||
555 | static Eina_Bool | ||
556 | _eina_value_type_uint_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
557 | { | ||
558 | unsigned int *tmem = mem; | ||
559 | const unsigned int *p = ptr; | ||
560 | *tmem = *p; | ||
561 | return EINA_TRUE; | ||
562 | } | ||
563 | |||
564 | static Eina_Bool | ||
565 | _eina_value_type_uint_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
566 | { | ||
567 | const unsigned int *tmem = mem; | ||
568 | unsigned int *p = ptr; | ||
569 | *p = *tmem; | ||
570 | return EINA_TRUE; | ||
571 | } | ||
572 | |||
573 | static Eina_Bool | ||
574 | _eina_value_type_ulong_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
575 | { | ||
576 | unsigned long *tmem = mem; | ||
577 | *tmem = 0; | ||
578 | return EINA_TRUE; | ||
579 | } | ||
580 | |||
581 | static Eina_Bool | ||
582 | _eina_value_type_ulong_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
583 | { | ||
584 | return EINA_TRUE; | ||
585 | } | ||
586 | |||
587 | static Eina_Bool | ||
588 | _eina_value_type_ulong_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
589 | { | ||
590 | const unsigned long *s = src; | ||
591 | unsigned long *d = dst; | ||
592 | *d = *s; | ||
593 | return EINA_TRUE; | ||
594 | } | ||
595 | |||
596 | static int | ||
597 | _eina_value_type_ulong_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
598 | { | ||
599 | const unsigned long *ta = a, *tb = b; | ||
600 | if (*ta < *tb) | ||
601 | return -1; | ||
602 | else if (*ta > *tb) | ||
603 | return 1; | ||
604 | return 0; | ||
605 | } | ||
606 | |||
607 | static Eina_Bool | ||
608 | _eina_value_type_ulong_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
609 | { | ||
610 | const unsigned long v = *(const unsigned long *)type_mem; | ||
611 | |||
612 | eina_error_set(0); | ||
613 | |||
614 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
615 | { | ||
616 | unsigned char other_mem = v; | ||
617 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
618 | return EINA_FALSE; | ||
619 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
620 | } | ||
621 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
622 | { | ||
623 | unsigned short other_mem = v; | ||
624 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
625 | return EINA_FALSE; | ||
626 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
627 | } | ||
628 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
629 | { | ||
630 | unsigned int other_mem = v; | ||
631 | if (EINA_UNLIKELY(v > eina_value_uint_max)) | ||
632 | return EINA_FALSE; | ||
633 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
634 | } | ||
635 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
636 | { | ||
637 | unsigned long other_mem = v; | ||
638 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
639 | } | ||
640 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
641 | { | ||
642 | uint64_t other_mem = v; | ||
643 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
644 | } | ||
645 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
646 | { | ||
647 | char other_mem = v; | ||
648 | if (EINA_UNLIKELY(v > (unsigned char)eina_value_char_max)) | ||
649 | return EINA_FALSE; | ||
650 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
651 | } | ||
652 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
653 | { | ||
654 | short other_mem = v; | ||
655 | if (EINA_UNLIKELY(v > (unsigned short)eina_value_short_max)) | ||
656 | return EINA_FALSE; | ||
657 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
658 | } | ||
659 | else if (convert == EINA_VALUE_TYPE_INT) | ||
660 | { | ||
661 | int other_mem = v; | ||
662 | if (EINA_UNLIKELY(v > (unsigned int)eina_value_int_max)) | ||
663 | return EINA_FALSE; | ||
664 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
665 | } | ||
666 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
667 | { | ||
668 | long other_mem = v; | ||
669 | if (EINA_UNLIKELY(v > (unsigned long)eina_value_long_max)) | ||
670 | return EINA_FALSE; | ||
671 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
672 | } | ||
673 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
674 | { | ||
675 | int64_t other_mem = v; | ||
676 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
677 | } | ||
678 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
679 | { | ||
680 | float other_mem = v; | ||
681 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
682 | } | ||
683 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
684 | { | ||
685 | double other_mem = v; | ||
686 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
687 | } | ||
688 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
689 | convert == EINA_VALUE_TYPE_STRING) | ||
690 | { | ||
691 | const char *other_mem; | ||
692 | char buf[64]; | ||
693 | snprintf(buf, sizeof(buf), "%lu", v); | ||
694 | other_mem = buf; /* required due &buf == buf */ | ||
695 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
696 | } | ||
697 | else | ||
698 | { | ||
699 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
700 | return EINA_FALSE; | ||
701 | } | ||
702 | |||
703 | return EINA_TRUE; | ||
704 | } | ||
705 | |||
706 | static Eina_Bool | ||
707 | _eina_value_type_ulong_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
708 | { | ||
709 | unsigned long *tmem = mem; | ||
710 | *tmem = va_arg(args, unsigned long); | ||
711 | return EINA_TRUE; | ||
712 | } | ||
713 | |||
714 | static Eina_Bool | ||
715 | _eina_value_type_ulong_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
716 | { | ||
717 | unsigned long *tmem = mem; | ||
718 | const unsigned long *p = ptr; | ||
719 | *tmem = *p; | ||
720 | return EINA_TRUE; | ||
721 | } | ||
722 | |||
723 | static Eina_Bool | ||
724 | _eina_value_type_ulong_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
725 | { | ||
726 | const unsigned long *tmem = mem; | ||
727 | unsigned long *p = ptr; | ||
728 | *p = *tmem; | ||
729 | return EINA_TRUE; | ||
730 | } | ||
731 | |||
732 | static Eina_Bool | ||
733 | _eina_value_type_uint64_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
734 | { | ||
735 | uint64_t *tmem = mem; | ||
736 | *tmem = 0; | ||
737 | return EINA_TRUE; | ||
738 | } | ||
739 | |||
740 | static Eina_Bool | ||
741 | _eina_value_type_uint64_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
742 | { | ||
743 | return EINA_TRUE; | ||
744 | } | ||
745 | |||
746 | static Eina_Bool | ||
747 | _eina_value_type_uint64_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
748 | { | ||
749 | const uint64_t *s = src; | ||
750 | uint64_t *d = dst; | ||
751 | *d = *s; | ||
752 | return EINA_TRUE; | ||
753 | } | ||
754 | |||
755 | static int | ||
756 | _eina_value_type_uint64_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
757 | { | ||
758 | const uint64_t *ta = a, *tb = b; | ||
759 | if (*ta < *tb) | ||
760 | return -1; | ||
761 | else if (*ta > *tb) | ||
762 | return 1; | ||
763 | return 0; | ||
764 | } | ||
765 | |||
766 | static Eina_Bool | ||
767 | _eina_value_type_uint64_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
768 | { | ||
769 | const uint64_t v = *(const uint64_t *)type_mem; | ||
770 | |||
771 | eina_error_set(0); | ||
772 | |||
773 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
774 | { | ||
775 | unsigned char other_mem = v; | ||
776 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
777 | return EINA_FALSE; | ||
778 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
779 | } | ||
780 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
781 | { | ||
782 | unsigned short other_mem = v; | ||
783 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
784 | return EINA_FALSE; | ||
785 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
786 | } | ||
787 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
788 | { | ||
789 | unsigned int other_mem = v; | ||
790 | if (EINA_UNLIKELY(v > eina_value_uint_max)) | ||
791 | return EINA_FALSE; | ||
792 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
793 | } | ||
794 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
795 | { | ||
796 | unsigned long other_mem = v; | ||
797 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && | ||
798 | (v > eina_value_ulong_max))) | ||
799 | return EINA_FALSE; | ||
800 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
801 | } | ||
802 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
803 | { | ||
804 | uint64_t other_mem = v; | ||
805 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
806 | } | ||
807 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
808 | { | ||
809 | char other_mem = v; | ||
810 | if (EINA_UNLIKELY(v > (unsigned char)eina_value_char_max)) | ||
811 | return EINA_FALSE; | ||
812 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
813 | } | ||
814 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
815 | { | ||
816 | short other_mem = v; | ||
817 | if (EINA_UNLIKELY(v > (unsigned short)eina_value_short_max)) | ||
818 | return EINA_FALSE; | ||
819 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
820 | } | ||
821 | else if (convert == EINA_VALUE_TYPE_INT) | ||
822 | { | ||
823 | int other_mem = v; | ||
824 | if (EINA_UNLIKELY(v > (unsigned int)eina_value_int_max)) | ||
825 | return EINA_FALSE; | ||
826 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
827 | } | ||
828 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
829 | { | ||
830 | long other_mem = v; | ||
831 | if (EINA_UNLIKELY(v > (unsigned long)eina_value_long_max)) | ||
832 | return EINA_FALSE; | ||
833 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
834 | } | ||
835 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
836 | { | ||
837 | int64_t other_mem = v; | ||
838 | if (EINA_UNLIKELY(v > (uint64_t)eina_value_int64_max)) | ||
839 | return EINA_FALSE; | ||
840 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
841 | } | ||
842 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
843 | { | ||
844 | float other_mem = v; | ||
845 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
846 | } | ||
847 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
848 | { | ||
849 | double other_mem = v; | ||
850 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
851 | } | ||
852 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
853 | convert == EINA_VALUE_TYPE_STRING) | ||
854 | { | ||
855 | const char *other_mem; | ||
856 | char buf[64]; | ||
857 | snprintf(buf, sizeof(buf), "%"PRIu64, v); | ||
858 | other_mem = buf; /* required due &buf == buf */ | ||
859 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
860 | } | ||
861 | else | ||
862 | { | ||
863 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
864 | return EINA_FALSE; | ||
865 | } | ||
866 | |||
867 | return EINA_TRUE; | ||
868 | } | ||
869 | |||
870 | static Eina_Bool | ||
871 | _eina_value_type_uint64_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
872 | { | ||
873 | uint64_t *tmem = mem; | ||
874 | *tmem = va_arg(args, uint64_t); | ||
875 | return EINA_TRUE; | ||
876 | } | ||
877 | |||
878 | static Eina_Bool | ||
879 | _eina_value_type_uint64_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
880 | { | ||
881 | uint64_t *tmem = mem; | ||
882 | const uint64_t *p = ptr; | ||
883 | *tmem = *p; | ||
884 | return EINA_TRUE; | ||
885 | } | ||
886 | |||
887 | static Eina_Bool | ||
888 | _eina_value_type_uint64_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
889 | { | ||
890 | const uint64_t *tmem = mem; | ||
891 | uint64_t *p = ptr; | ||
892 | *p = *tmem; | ||
893 | return EINA_TRUE; | ||
894 | } | ||
895 | |||
896 | static Eina_Bool | ||
897 | _eina_value_type_char_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
898 | { | ||
899 | char *tmem = mem; | ||
900 | *tmem = 0; | ||
901 | return EINA_TRUE; | ||
902 | } | ||
903 | |||
904 | static Eina_Bool | ||
905 | _eina_value_type_char_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
906 | { | ||
907 | return EINA_TRUE; | ||
908 | } | ||
909 | |||
910 | static Eina_Bool | ||
911 | _eina_value_type_char_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
912 | { | ||
913 | const char *s = src; | ||
914 | char *d = dst; | ||
915 | *d = *s; | ||
916 | return EINA_TRUE; | ||
917 | } | ||
918 | |||
919 | static int | ||
920 | _eina_value_type_char_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
921 | { | ||
922 | const char *ta = a, *tb = b; | ||
923 | if (*ta < *tb) | ||
924 | return -1; | ||
925 | else if (*ta > *tb) | ||
926 | return 1; | ||
927 | return 0; | ||
928 | } | ||
929 | |||
930 | static Eina_Bool | ||
931 | _eina_value_type_char_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
932 | { | ||
933 | const signed char v = *(const signed char *)type_mem; | ||
934 | |||
935 | eina_error_set(0); | ||
936 | |||
937 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
938 | { | ||
939 | unsigned char other_mem = v; | ||
940 | if (EINA_UNLIKELY(v < 0)) | ||
941 | return EINA_FALSE; | ||
942 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
943 | } | ||
944 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
945 | { | ||
946 | unsigned short other_mem = v; | ||
947 | if (EINA_UNLIKELY(v < 0)) | ||
948 | return EINA_FALSE; | ||
949 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
950 | } | ||
951 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
952 | { | ||
953 | unsigned int other_mem = v; | ||
954 | if (EINA_UNLIKELY(v < 0)) | ||
955 | return EINA_FALSE; | ||
956 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
957 | } | ||
958 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
959 | { | ||
960 | unsigned long other_mem = v; | ||
961 | if (EINA_UNLIKELY(v < 0)) | ||
962 | return EINA_FALSE; | ||
963 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
964 | } | ||
965 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
966 | { | ||
967 | uint64_t other_mem = v; | ||
968 | if (EINA_UNLIKELY(v < 0)) | ||
969 | return EINA_FALSE; | ||
970 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
971 | } | ||
972 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
973 | { | ||
974 | char other_mem = v; | ||
975 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
976 | } | ||
977 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
978 | { | ||
979 | short other_mem = v; | ||
980 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
981 | } | ||
982 | else if (convert == EINA_VALUE_TYPE_INT) | ||
983 | { | ||
984 | int other_mem = v; | ||
985 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
986 | } | ||
987 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
988 | { | ||
989 | long other_mem = v; | ||
990 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
991 | } | ||
992 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
993 | { | ||
994 | int64_t other_mem = v; | ||
995 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
996 | } | ||
997 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
998 | { | ||
999 | float other_mem = v; | ||
1000 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1001 | } | ||
1002 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
1003 | { | ||
1004 | double other_mem = v; | ||
1005 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1006 | } | ||
1007 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
1008 | convert == EINA_VALUE_TYPE_STRING) | ||
1009 | { | ||
1010 | const char *other_mem; | ||
1011 | char buf[64]; | ||
1012 | snprintf(buf, sizeof(buf), "%hhd", v); | ||
1013 | other_mem = buf; /* required due &buf == buf */ | ||
1014 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1015 | } | ||
1016 | else | ||
1017 | { | ||
1018 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
1019 | return EINA_FALSE; | ||
1020 | } | ||
1021 | |||
1022 | return EINA_TRUE; | ||
1023 | } | ||
1024 | |||
1025 | static Eina_Bool | ||
1026 | _eina_value_type_char_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
1027 | { | ||
1028 | char *tmem = mem; | ||
1029 | *tmem = va_arg(args, int); /* char is promoted to int for va_arg */ | ||
1030 | return EINA_TRUE; | ||
1031 | } | ||
1032 | |||
1033 | static Eina_Bool | ||
1034 | _eina_value_type_char_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
1035 | { | ||
1036 | char *tmem = mem; | ||
1037 | const char *p = ptr; | ||
1038 | *tmem = *p; | ||
1039 | return EINA_TRUE; | ||
1040 | } | ||
1041 | |||
1042 | static Eina_Bool | ||
1043 | _eina_value_type_char_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
1044 | { | ||
1045 | const char *tmem = mem; | ||
1046 | char *p = ptr; | ||
1047 | *p = *tmem; | ||
1048 | return EINA_TRUE; | ||
1049 | } | ||
1050 | |||
1051 | static Eina_Bool | ||
1052 | _eina_value_type_short_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
1053 | { | ||
1054 | short *tmem = mem; | ||
1055 | *tmem = 0; | ||
1056 | return EINA_TRUE; | ||
1057 | } | ||
1058 | |||
1059 | static Eina_Bool | ||
1060 | _eina_value_type_short_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
1061 | { | ||
1062 | return EINA_TRUE; | ||
1063 | } | ||
1064 | |||
1065 | static Eina_Bool | ||
1066 | _eina_value_type_short_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
1067 | { | ||
1068 | const short *s = src; | ||
1069 | short *d = dst; | ||
1070 | *d = *s; | ||
1071 | return EINA_TRUE; | ||
1072 | } | ||
1073 | |||
1074 | static int | ||
1075 | _eina_value_type_short_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
1076 | { | ||
1077 | const short *ta = a, *tb = b; | ||
1078 | if (*ta < *tb) | ||
1079 | return -1; | ||
1080 | else if (*ta > *tb) | ||
1081 | return 1; | ||
1082 | return 0; | ||
1083 | } | ||
1084 | |||
1085 | static Eina_Bool | ||
1086 | _eina_value_type_short_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
1087 | { | ||
1088 | const short v = *(const short *)type_mem; | ||
1089 | |||
1090 | eina_error_set(0); | ||
1091 | |||
1092 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
1093 | { | ||
1094 | unsigned char other_mem = v; | ||
1095 | if (EINA_UNLIKELY(v < 0)) | ||
1096 | return EINA_FALSE; | ||
1097 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
1098 | return EINA_FALSE; | ||
1099 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1100 | } | ||
1101 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
1102 | { | ||
1103 | unsigned short other_mem = v; | ||
1104 | if (EINA_UNLIKELY(v < 0)) | ||
1105 | return EINA_FALSE; | ||
1106 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1107 | } | ||
1108 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
1109 | { | ||
1110 | unsigned int other_mem = v; | ||
1111 | if (EINA_UNLIKELY(v < 0)) | ||
1112 | return EINA_FALSE; | ||
1113 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1114 | } | ||
1115 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
1116 | { | ||
1117 | unsigned long other_mem = v; | ||
1118 | if (EINA_UNLIKELY(v < 0)) | ||
1119 | return EINA_FALSE; | ||
1120 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1121 | } | ||
1122 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
1123 | { | ||
1124 | uint64_t other_mem = v; | ||
1125 | if (EINA_UNLIKELY(v < 0)) | ||
1126 | return EINA_FALSE; | ||
1127 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1128 | } | ||
1129 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
1130 | { | ||
1131 | char other_mem = v; | ||
1132 | if (EINA_UNLIKELY(v < eina_value_char_min)) | ||
1133 | return EINA_FALSE; | ||
1134 | if (EINA_UNLIKELY(v > eina_value_char_max)) | ||
1135 | return EINA_FALSE; | ||
1136 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1137 | } | ||
1138 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
1139 | { | ||
1140 | short other_mem = v; | ||
1141 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1142 | } | ||
1143 | else if (convert == EINA_VALUE_TYPE_INT) | ||
1144 | { | ||
1145 | int other_mem = v; | ||
1146 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1147 | } | ||
1148 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
1149 | { | ||
1150 | long other_mem = v; | ||
1151 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1152 | } | ||
1153 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
1154 | { | ||
1155 | int64_t other_mem = v; | ||
1156 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1157 | } | ||
1158 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
1159 | { | ||
1160 | float other_mem = v; | ||
1161 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1162 | } | ||
1163 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
1164 | { | ||
1165 | double other_mem = v; | ||
1166 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1167 | } | ||
1168 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
1169 | convert == EINA_VALUE_TYPE_STRING) | ||
1170 | { | ||
1171 | const char *other_mem; | ||
1172 | char buf[64]; | ||
1173 | snprintf(buf, sizeof(buf), "%hd", v); | ||
1174 | other_mem = buf; /* required due &buf == buf */ | ||
1175 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1176 | } | ||
1177 | else | ||
1178 | { | ||
1179 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
1180 | return EINA_FALSE; | ||
1181 | } | ||
1182 | |||
1183 | return EINA_TRUE; | ||
1184 | } | ||
1185 | |||
1186 | static Eina_Bool | ||
1187 | _eina_value_type_short_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
1188 | { | ||
1189 | short *tmem = mem; | ||
1190 | *tmem = va_arg(args, int); /* short int is promoted to int for va_arg */ | ||
1191 | return EINA_TRUE; | ||
1192 | } | ||
1193 | |||
1194 | static Eina_Bool | ||
1195 | _eina_value_type_short_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
1196 | { | ||
1197 | short *tmem = mem; | ||
1198 | const short *p = ptr; | ||
1199 | *tmem = *p; | ||
1200 | return EINA_TRUE; | ||
1201 | } | ||
1202 | |||
1203 | static Eina_Bool | ||
1204 | _eina_value_type_short_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
1205 | { | ||
1206 | const short *tmem = mem; | ||
1207 | short *p = ptr; | ||
1208 | *p = *tmem; | ||
1209 | return EINA_TRUE; | ||
1210 | } | ||
1211 | |||
1212 | static Eina_Bool | ||
1213 | _eina_value_type_int_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
1214 | { | ||
1215 | int *tmem = mem; | ||
1216 | *tmem = 0; | ||
1217 | return EINA_TRUE; | ||
1218 | } | ||
1219 | |||
1220 | static Eina_Bool | ||
1221 | _eina_value_type_int_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
1222 | { | ||
1223 | return EINA_TRUE; | ||
1224 | } | ||
1225 | |||
1226 | static Eina_Bool | ||
1227 | _eina_value_type_int_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
1228 | { | ||
1229 | const int *s = src; | ||
1230 | int *d = dst; | ||
1231 | *d = *s; | ||
1232 | return EINA_TRUE; | ||
1233 | } | ||
1234 | |||
1235 | static int | ||
1236 | _eina_value_type_int_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
1237 | { | ||
1238 | const int *ta = a, *tb = b; | ||
1239 | if (*ta < *tb) | ||
1240 | return -1; | ||
1241 | else if (*ta > *tb) | ||
1242 | return 1; | ||
1243 | return 0; | ||
1244 | } | ||
1245 | |||
1246 | static Eina_Bool | ||
1247 | _eina_value_type_int_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
1248 | { | ||
1249 | const int v = *(const int *)type_mem; | ||
1250 | |||
1251 | eina_error_set(0); | ||
1252 | |||
1253 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
1254 | { | ||
1255 | unsigned char other_mem = v; | ||
1256 | if (EINA_UNLIKELY(v < 0)) | ||
1257 | return EINA_FALSE; | ||
1258 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
1259 | return EINA_FALSE; | ||
1260 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1261 | } | ||
1262 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
1263 | { | ||
1264 | unsigned short other_mem = v; | ||
1265 | if (EINA_UNLIKELY(v < 0)) | ||
1266 | return EINA_FALSE; | ||
1267 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
1268 | return EINA_FALSE; | ||
1269 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1270 | } | ||
1271 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
1272 | { | ||
1273 | unsigned int other_mem = v; | ||
1274 | if (EINA_UNLIKELY(v < 0)) | ||
1275 | return EINA_FALSE; | ||
1276 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1277 | } | ||
1278 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
1279 | { | ||
1280 | unsigned long other_mem = v; | ||
1281 | if (EINA_UNLIKELY(v < 0)) | ||
1282 | return EINA_FALSE; | ||
1283 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1284 | } | ||
1285 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
1286 | { | ||
1287 | uint64_t other_mem = v; | ||
1288 | if (EINA_UNLIKELY(v < 0)) | ||
1289 | return EINA_FALSE; | ||
1290 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1291 | } | ||
1292 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
1293 | { | ||
1294 | char other_mem = v; | ||
1295 | if (EINA_UNLIKELY(v < eina_value_char_min)) | ||
1296 | return EINA_FALSE; | ||
1297 | if (EINA_UNLIKELY(v > eina_value_char_max)) | ||
1298 | return EINA_FALSE; | ||
1299 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1300 | } | ||
1301 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
1302 | { | ||
1303 | short other_mem = v; | ||
1304 | if (EINA_UNLIKELY(v < eina_value_short_min)) | ||
1305 | return EINA_FALSE; | ||
1306 | if (EINA_UNLIKELY(v > eina_value_short_max)) | ||
1307 | return EINA_FALSE; | ||
1308 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1309 | } | ||
1310 | else if (convert == EINA_VALUE_TYPE_INT) | ||
1311 | { | ||
1312 | int other_mem = v; | ||
1313 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1314 | } | ||
1315 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
1316 | { | ||
1317 | long other_mem = v; | ||
1318 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1319 | } | ||
1320 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
1321 | { | ||
1322 | int64_t other_mem = v; | ||
1323 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1324 | } | ||
1325 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
1326 | { | ||
1327 | float other_mem = v; | ||
1328 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1329 | } | ||
1330 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
1331 | { | ||
1332 | double other_mem = v; | ||
1333 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1334 | } | ||
1335 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
1336 | convert == EINA_VALUE_TYPE_STRING) | ||
1337 | { | ||
1338 | const char *other_mem; | ||
1339 | char buf[64]; | ||
1340 | snprintf(buf, sizeof(buf), "%d", v); | ||
1341 | other_mem = buf; /* required due &buf == buf */ | ||
1342 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1343 | } | ||
1344 | else | ||
1345 | { | ||
1346 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
1347 | return EINA_FALSE; | ||
1348 | } | ||
1349 | |||
1350 | return EINA_TRUE; | ||
1351 | } | ||
1352 | |||
1353 | static Eina_Bool | ||
1354 | _eina_value_type_int_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
1355 | { | ||
1356 | int *tmem = mem; | ||
1357 | *tmem = va_arg(args, int); | ||
1358 | return EINA_TRUE; | ||
1359 | } | ||
1360 | |||
1361 | static Eina_Bool | ||
1362 | _eina_value_type_int_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
1363 | { | ||
1364 | int *tmem = mem; | ||
1365 | const int *p = ptr; | ||
1366 | *tmem = *p; | ||
1367 | return EINA_TRUE; | ||
1368 | } | ||
1369 | |||
1370 | static Eina_Bool | ||
1371 | _eina_value_type_int_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
1372 | { | ||
1373 | const int *tmem = mem; | ||
1374 | int *p = ptr; | ||
1375 | *p = *tmem; | ||
1376 | return EINA_TRUE; | ||
1377 | } | ||
1378 | |||
1379 | static Eina_Bool | ||
1380 | _eina_value_type_long_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
1381 | { | ||
1382 | long *tmem = mem; | ||
1383 | *tmem = 0; | ||
1384 | return EINA_TRUE; | ||
1385 | } | ||
1386 | |||
1387 | static Eina_Bool | ||
1388 | _eina_value_type_long_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
1389 | { | ||
1390 | return EINA_TRUE; | ||
1391 | } | ||
1392 | |||
1393 | static Eina_Bool | ||
1394 | _eina_value_type_long_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
1395 | { | ||
1396 | const long *s = src; | ||
1397 | long *d = dst; | ||
1398 | *d = *s; | ||
1399 | return EINA_TRUE; | ||
1400 | } | ||
1401 | |||
1402 | static int | ||
1403 | _eina_value_type_long_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
1404 | { | ||
1405 | const long *ta = a, *tb = b; | ||
1406 | if (*ta < *tb) | ||
1407 | return -1; | ||
1408 | else if (*ta > *tb) | ||
1409 | return 1; | ||
1410 | return 0; | ||
1411 | } | ||
1412 | |||
1413 | static Eina_Bool | ||
1414 | _eina_value_type_long_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
1415 | { | ||
1416 | const long v = *(const long *)type_mem; | ||
1417 | |||
1418 | eina_error_set(0); | ||
1419 | |||
1420 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
1421 | { | ||
1422 | unsigned char other_mem = v; | ||
1423 | if (EINA_UNLIKELY(v < 0)) | ||
1424 | return EINA_FALSE; | ||
1425 | if (EINA_UNLIKELY((unsigned long) v > eina_value_uchar_max)) | ||
1426 | return EINA_FALSE; | ||
1427 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1428 | } | ||
1429 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
1430 | { | ||
1431 | unsigned short other_mem = v; | ||
1432 | if (EINA_UNLIKELY(v < 0)) | ||
1433 | return EINA_FALSE; | ||
1434 | if (EINA_UNLIKELY((unsigned long) v > eina_value_ushort_max)) | ||
1435 | return EINA_FALSE; | ||
1436 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1437 | } | ||
1438 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
1439 | { | ||
1440 | unsigned int other_mem = v; | ||
1441 | if (EINA_UNLIKELY(v < 0)) | ||
1442 | return EINA_FALSE; | ||
1443 | if (EINA_UNLIKELY((unsigned long) v > eina_value_uint_max)) | ||
1444 | return EINA_FALSE; | ||
1445 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1446 | } | ||
1447 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
1448 | { | ||
1449 | unsigned long other_mem = v; | ||
1450 | if (EINA_UNLIKELY(v < 0)) | ||
1451 | return EINA_FALSE; | ||
1452 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1453 | } | ||
1454 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
1455 | { | ||
1456 | uint64_t other_mem = v; | ||
1457 | if (EINA_UNLIKELY(v < 0)) | ||
1458 | return EINA_FALSE; | ||
1459 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1460 | } | ||
1461 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
1462 | { | ||
1463 | char other_mem = v; | ||
1464 | if (EINA_UNLIKELY(v < eina_value_char_min)) | ||
1465 | return EINA_FALSE; | ||
1466 | if (EINA_UNLIKELY(v > eina_value_char_max)) | ||
1467 | return EINA_FALSE; | ||
1468 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1469 | } | ||
1470 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
1471 | { | ||
1472 | short other_mem = v; | ||
1473 | if (EINA_UNLIKELY(v < eina_value_short_min)) | ||
1474 | return EINA_FALSE; | ||
1475 | if (EINA_UNLIKELY(v > eina_value_short_max)) | ||
1476 | return EINA_FALSE; | ||
1477 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1478 | } | ||
1479 | else if (convert == EINA_VALUE_TYPE_INT) | ||
1480 | { | ||
1481 | int other_mem = v; | ||
1482 | if (EINA_UNLIKELY(v < eina_value_int_min)) | ||
1483 | return EINA_FALSE; | ||
1484 | if (EINA_UNLIKELY(v > eina_value_int_max)) | ||
1485 | return EINA_FALSE; | ||
1486 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1487 | } | ||
1488 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
1489 | { | ||
1490 | long other_mem = v; | ||
1491 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1492 | } | ||
1493 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
1494 | { | ||
1495 | int64_t other_mem = v; | ||
1496 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1497 | } | ||
1498 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
1499 | { | ||
1500 | float other_mem = v; | ||
1501 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1502 | } | ||
1503 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
1504 | { | ||
1505 | double other_mem = v; | ||
1506 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1507 | } | ||
1508 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
1509 | convert == EINA_VALUE_TYPE_STRING) | ||
1510 | { | ||
1511 | const char *other_mem; | ||
1512 | char buf[64]; | ||
1513 | snprintf(buf, sizeof(buf), "%ld", v); | ||
1514 | other_mem = buf; /* required due &buf == buf */ | ||
1515 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1516 | } | ||
1517 | else | ||
1518 | { | ||
1519 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
1520 | return EINA_FALSE; | ||
1521 | } | ||
1522 | |||
1523 | return EINA_TRUE; | ||
1524 | } | ||
1525 | |||
1526 | static Eina_Bool | ||
1527 | _eina_value_type_long_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
1528 | { | ||
1529 | long *tmem = mem; | ||
1530 | *tmem = va_arg(args, long); | ||
1531 | return EINA_TRUE; | ||
1532 | } | ||
1533 | |||
1534 | static Eina_Bool | ||
1535 | _eina_value_type_long_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
1536 | { | ||
1537 | long *tmem = mem; | ||
1538 | const long *p = ptr; | ||
1539 | *tmem = *p; | ||
1540 | return EINA_TRUE; | ||
1541 | } | ||
1542 | |||
1543 | static Eina_Bool | ||
1544 | _eina_value_type_long_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
1545 | { | ||
1546 | const long *tmem = mem; | ||
1547 | long *p = ptr; | ||
1548 | *p = *tmem; | ||
1549 | return EINA_TRUE; | ||
1550 | } | ||
1551 | |||
1552 | static Eina_Bool | ||
1553 | _eina_value_type_int64_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
1554 | { | ||
1555 | int64_t *tmem = mem; | ||
1556 | *tmem = 0; | ||
1557 | return EINA_TRUE; | ||
1558 | } | ||
1559 | |||
1560 | static Eina_Bool | ||
1561 | _eina_value_type_int64_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
1562 | { | ||
1563 | return EINA_TRUE; | ||
1564 | } | ||
1565 | |||
1566 | static Eina_Bool | ||
1567 | _eina_value_type_int64_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
1568 | { | ||
1569 | const int64_t *s = src; | ||
1570 | int64_t *d = dst; | ||
1571 | *d = *s; | ||
1572 | return EINA_TRUE; | ||
1573 | } | ||
1574 | |||
1575 | static int | ||
1576 | _eina_value_type_int64_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
1577 | { | ||
1578 | const int64_t *ta = a, *tb = b; | ||
1579 | if (*ta < *tb) | ||
1580 | return -1; | ||
1581 | else if (*ta > *tb) | ||
1582 | return 1; | ||
1583 | return 0; | ||
1584 | } | ||
1585 | |||
1586 | static Eina_Bool | ||
1587 | _eina_value_type_int64_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
1588 | { | ||
1589 | const int64_t v = *(const int64_t *)type_mem; | ||
1590 | |||
1591 | eina_error_set(0); | ||
1592 | |||
1593 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
1594 | { | ||
1595 | unsigned char other_mem = v; | ||
1596 | if (EINA_UNLIKELY(v < 0)) | ||
1597 | return EINA_FALSE; | ||
1598 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
1599 | return EINA_FALSE; | ||
1600 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1601 | } | ||
1602 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
1603 | { | ||
1604 | unsigned short other_mem = v; | ||
1605 | if (EINA_UNLIKELY(v < 0)) | ||
1606 | return EINA_FALSE; | ||
1607 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
1608 | return EINA_FALSE; | ||
1609 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1610 | } | ||
1611 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
1612 | { | ||
1613 | unsigned int other_mem = v; | ||
1614 | if (EINA_UNLIKELY(v < 0)) | ||
1615 | return EINA_FALSE; | ||
1616 | if (EINA_UNLIKELY(v > eina_value_uint_max)) | ||
1617 | return EINA_FALSE; | ||
1618 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1619 | } | ||
1620 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
1621 | { | ||
1622 | unsigned long other_mem = v; | ||
1623 | if (EINA_UNLIKELY(v < 0)) | ||
1624 | return EINA_FALSE; | ||
1625 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && | ||
1626 | (v > eina_value_ulong_max))) | ||
1627 | return EINA_FALSE; | ||
1628 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1629 | } | ||
1630 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
1631 | { | ||
1632 | uint64_t other_mem = v; | ||
1633 | if (EINA_UNLIKELY(v < 0)) | ||
1634 | return EINA_FALSE; | ||
1635 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1636 | } | ||
1637 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
1638 | { | ||
1639 | char other_mem = v; | ||
1640 | if (EINA_UNLIKELY(v < eina_value_char_min)) | ||
1641 | return EINA_FALSE; | ||
1642 | if (EINA_UNLIKELY(v > eina_value_char_max)) | ||
1643 | return EINA_FALSE; | ||
1644 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1645 | } | ||
1646 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
1647 | { | ||
1648 | short other_mem = v; | ||
1649 | if (EINA_UNLIKELY(v < eina_value_short_min)) | ||
1650 | return EINA_FALSE; | ||
1651 | if (EINA_UNLIKELY(v > eina_value_short_max)) | ||
1652 | return EINA_FALSE; | ||
1653 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1654 | } | ||
1655 | else if (convert == EINA_VALUE_TYPE_INT) | ||
1656 | { | ||
1657 | int other_mem = v; | ||
1658 | if (EINA_UNLIKELY(v < eina_value_int_min)) | ||
1659 | return EINA_FALSE; | ||
1660 | if (EINA_UNLIKELY(v > eina_value_int_max)) | ||
1661 | return EINA_FALSE; | ||
1662 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1663 | } | ||
1664 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
1665 | { | ||
1666 | long other_mem = v; | ||
1667 | if (EINA_UNLIKELY(v < eina_value_long_min)) | ||
1668 | return EINA_FALSE; | ||
1669 | if (EINA_UNLIKELY(v > eina_value_long_max)) | ||
1670 | return EINA_FALSE; | ||
1671 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1672 | } | ||
1673 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
1674 | { | ||
1675 | int64_t other_mem = v; | ||
1676 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1677 | } | ||
1678 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
1679 | { | ||
1680 | float other_mem = v; | ||
1681 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1682 | } | ||
1683 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
1684 | { | ||
1685 | double other_mem = v; | ||
1686 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1687 | } | ||
1688 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
1689 | convert == EINA_VALUE_TYPE_STRING) | ||
1690 | { | ||
1691 | const char *other_mem; | ||
1692 | char buf[64]; | ||
1693 | snprintf(buf, sizeof(buf), "%"PRId64, v); | ||
1694 | other_mem = buf; /* required due &buf == buf */ | ||
1695 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1696 | } | ||
1697 | else | ||
1698 | { | ||
1699 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
1700 | return EINA_FALSE; | ||
1701 | } | ||
1702 | |||
1703 | return EINA_TRUE; | ||
1704 | } | ||
1705 | |||
1706 | static Eina_Bool | ||
1707 | _eina_value_type_int64_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
1708 | { | ||
1709 | int64_t *tmem = mem; | ||
1710 | *tmem = va_arg(args, int64_t); | ||
1711 | return EINA_TRUE; | ||
1712 | } | ||
1713 | |||
1714 | static Eina_Bool | ||
1715 | _eina_value_type_int64_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
1716 | { | ||
1717 | int64_t *tmem = mem; | ||
1718 | const int64_t *p = ptr; | ||
1719 | *tmem = *p; | ||
1720 | return EINA_TRUE; | ||
1721 | } | ||
1722 | |||
1723 | static Eina_Bool | ||
1724 | _eina_value_type_int64_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
1725 | { | ||
1726 | const int64_t *tmem = mem; | ||
1727 | int64_t *p = ptr; | ||
1728 | *p = *tmem; | ||
1729 | return EINA_TRUE; | ||
1730 | } | ||
1731 | |||
1732 | static Eina_Bool | ||
1733 | _eina_value_type_float_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
1734 | { | ||
1735 | float *tmem = mem; | ||
1736 | *tmem = 0; | ||
1737 | return EINA_TRUE; | ||
1738 | } | ||
1739 | |||
1740 | static Eina_Bool | ||
1741 | _eina_value_type_float_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
1742 | { | ||
1743 | return EINA_TRUE; | ||
1744 | } | ||
1745 | |||
1746 | static Eina_Bool | ||
1747 | _eina_value_type_float_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
1748 | { | ||
1749 | const float *s = src; | ||
1750 | float *d = dst; | ||
1751 | *d = *s; | ||
1752 | return EINA_TRUE; | ||
1753 | } | ||
1754 | |||
1755 | static int | ||
1756 | _eina_value_type_float_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
1757 | { | ||
1758 | const float *ta = a, *tb = b; | ||
1759 | if (*ta < *tb) | ||
1760 | return -1; | ||
1761 | else if (*ta > *tb) | ||
1762 | return 1; | ||
1763 | return 0; | ||
1764 | } | ||
1765 | |||
1766 | static Eina_Bool | ||
1767 | _eina_value_type_float_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
1768 | { | ||
1769 | const float v = *(const float *)type_mem; | ||
1770 | |||
1771 | eina_error_set(0); | ||
1772 | |||
1773 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
1774 | { | ||
1775 | unsigned char other_mem = v; | ||
1776 | if (EINA_UNLIKELY(v < 0)) | ||
1777 | return EINA_FALSE; | ||
1778 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
1779 | return EINA_FALSE; | ||
1780 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1781 | } | ||
1782 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
1783 | { | ||
1784 | unsigned short other_mem = v; | ||
1785 | if (EINA_UNLIKELY(v < 0)) | ||
1786 | return EINA_FALSE; | ||
1787 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
1788 | return EINA_FALSE; | ||
1789 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1790 | } | ||
1791 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
1792 | { | ||
1793 | unsigned int other_mem = v; | ||
1794 | if (EINA_UNLIKELY(v < 0)) | ||
1795 | return EINA_FALSE; | ||
1796 | if (EINA_UNLIKELY(v > eina_value_uint_max)) | ||
1797 | return EINA_FALSE; | ||
1798 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1799 | } | ||
1800 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
1801 | { | ||
1802 | unsigned long other_mem = v; | ||
1803 | if (EINA_UNLIKELY(v < 0)) | ||
1804 | return EINA_FALSE; | ||
1805 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && | ||
1806 | (v > eina_value_ulong_max))) | ||
1807 | return EINA_FALSE; | ||
1808 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1809 | } | ||
1810 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
1811 | { | ||
1812 | uint64_t other_mem = v; | ||
1813 | if (EINA_UNLIKELY(v < 0)) | ||
1814 | return EINA_FALSE; | ||
1815 | if (EINA_UNLIKELY(v > eina_value_uint64_max)) | ||
1816 | return EINA_FALSE; | ||
1817 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1818 | } | ||
1819 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
1820 | { | ||
1821 | char other_mem = v; | ||
1822 | if (EINA_UNLIKELY(v < eina_value_char_min)) | ||
1823 | return EINA_FALSE; | ||
1824 | if (EINA_UNLIKELY(v > eina_value_char_max)) | ||
1825 | return EINA_FALSE; | ||
1826 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1827 | } | ||
1828 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
1829 | { | ||
1830 | short other_mem = v; | ||
1831 | if (EINA_UNLIKELY(v < eina_value_short_min)) | ||
1832 | return EINA_FALSE; | ||
1833 | if (EINA_UNLIKELY(v > eina_value_short_max)) | ||
1834 | return EINA_FALSE; | ||
1835 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1836 | } | ||
1837 | else if (convert == EINA_VALUE_TYPE_INT) | ||
1838 | { | ||
1839 | int other_mem = v; | ||
1840 | if (EINA_UNLIKELY(v < eina_value_int_min)) | ||
1841 | return EINA_FALSE; | ||
1842 | if (EINA_UNLIKELY(v > eina_value_int_max)) | ||
1843 | return EINA_FALSE; | ||
1844 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1845 | } | ||
1846 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
1847 | { | ||
1848 | long other_mem = v; | ||
1849 | if (EINA_UNLIKELY(v < eina_value_long_min)) | ||
1850 | return EINA_FALSE; | ||
1851 | if (EINA_UNLIKELY(v > eina_value_long_max)) | ||
1852 | return EINA_FALSE; | ||
1853 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1854 | } | ||
1855 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
1856 | { | ||
1857 | int64_t other_mem = v; | ||
1858 | if (EINA_UNLIKELY(v < eina_value_int64_min)) | ||
1859 | return EINA_FALSE; | ||
1860 | if (EINA_UNLIKELY(v > eina_value_int64_max)) | ||
1861 | return EINA_FALSE; | ||
1862 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1863 | } | ||
1864 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
1865 | { | ||
1866 | float other_mem = v; | ||
1867 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1868 | } | ||
1869 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
1870 | { | ||
1871 | double other_mem = v; | ||
1872 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1873 | } | ||
1874 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
1875 | convert == EINA_VALUE_TYPE_STRING) | ||
1876 | { | ||
1877 | const char *other_mem; | ||
1878 | char buf[64]; | ||
1879 | snprintf(buf, sizeof(buf), "%f", v); | ||
1880 | other_mem = buf; /* required due &buf == buf */ | ||
1881 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1882 | } | ||
1883 | else | ||
1884 | { | ||
1885 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
1886 | return EINA_FALSE; | ||
1887 | } | ||
1888 | |||
1889 | return EINA_TRUE; | ||
1890 | } | ||
1891 | |||
1892 | static Eina_Bool | ||
1893 | _eina_value_type_float_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
1894 | { | ||
1895 | float *tmem = mem; | ||
1896 | *tmem = va_arg(args, double); /* float is promoted to double for va_args */ | ||
1897 | return EINA_TRUE; | ||
1898 | } | ||
1899 | |||
1900 | static Eina_Bool | ||
1901 | _eina_value_type_float_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
1902 | { | ||
1903 | float *tmem = mem; | ||
1904 | const float *p = ptr; | ||
1905 | *tmem = *p; | ||
1906 | return EINA_TRUE; | ||
1907 | } | ||
1908 | |||
1909 | static Eina_Bool | ||
1910 | _eina_value_type_float_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
1911 | { | ||
1912 | const float *tmem = mem; | ||
1913 | float *p = ptr; | ||
1914 | *p = *tmem; | ||
1915 | return EINA_TRUE; | ||
1916 | } | ||
1917 | |||
1918 | static Eina_Bool | ||
1919 | _eina_value_type_double_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
1920 | { | ||
1921 | double *tmem = mem; | ||
1922 | *tmem = 0; | ||
1923 | return EINA_TRUE; | ||
1924 | } | ||
1925 | |||
1926 | static Eina_Bool | ||
1927 | _eina_value_type_double_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
1928 | { | ||
1929 | return EINA_TRUE; | ||
1930 | } | ||
1931 | |||
1932 | static Eina_Bool | ||
1933 | _eina_value_type_double_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
1934 | { | ||
1935 | const double *s = src; | ||
1936 | double *d = dst; | ||
1937 | *d = *s; | ||
1938 | return EINA_TRUE; | ||
1939 | } | ||
1940 | |||
1941 | static int | ||
1942 | _eina_value_type_double_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
1943 | { | ||
1944 | const double *ta = a, *tb = b; | ||
1945 | if (*ta < *tb) | ||
1946 | return -1; | ||
1947 | else if (*ta > *tb) | ||
1948 | return 1; | ||
1949 | return 0; | ||
1950 | } | ||
1951 | |||
1952 | static Eina_Bool | ||
1953 | _eina_value_type_double_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
1954 | { | ||
1955 | const double v = *(const double *)type_mem; | ||
1956 | |||
1957 | eina_error_set(0); | ||
1958 | |||
1959 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
1960 | { | ||
1961 | unsigned char other_mem = v; | ||
1962 | if (EINA_UNLIKELY(v < 0)) | ||
1963 | return EINA_FALSE; | ||
1964 | if (EINA_UNLIKELY(v > eina_value_uchar_max)) | ||
1965 | return EINA_FALSE; | ||
1966 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1967 | } | ||
1968 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
1969 | { | ||
1970 | unsigned short other_mem = v; | ||
1971 | if (EINA_UNLIKELY(v < 0)) | ||
1972 | return EINA_FALSE; | ||
1973 | if (EINA_UNLIKELY(v > eina_value_ushort_max)) | ||
1974 | return EINA_FALSE; | ||
1975 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1976 | } | ||
1977 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
1978 | { | ||
1979 | unsigned int other_mem = v; | ||
1980 | if (EINA_UNLIKELY(v < 0)) | ||
1981 | return EINA_FALSE; | ||
1982 | if (EINA_UNLIKELY(v > eina_value_uint_max)) | ||
1983 | return EINA_FALSE; | ||
1984 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1985 | } | ||
1986 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
1987 | { | ||
1988 | unsigned long other_mem = v; | ||
1989 | if (EINA_UNLIKELY(v < 0)) | ||
1990 | return EINA_FALSE; | ||
1991 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && | ||
1992 | (v > eina_value_ulong_max))) | ||
1993 | return EINA_FALSE; | ||
1994 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
1995 | } | ||
1996 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
1997 | { | ||
1998 | uint64_t other_mem = v; | ||
1999 | if (EINA_UNLIKELY(v < 0)) | ||
2000 | return EINA_FALSE; | ||
2001 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2002 | } | ||
2003 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
2004 | { | ||
2005 | char other_mem = v; | ||
2006 | if (EINA_UNLIKELY(v < eina_value_char_min)) | ||
2007 | return EINA_FALSE; | ||
2008 | if (EINA_UNLIKELY(v > eina_value_char_max)) | ||
2009 | return EINA_FALSE; | ||
2010 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2011 | } | ||
2012 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
2013 | { | ||
2014 | short other_mem = v; | ||
2015 | if (EINA_UNLIKELY(v < eina_value_short_min)) | ||
2016 | return EINA_FALSE; | ||
2017 | if (EINA_UNLIKELY(v > eina_value_short_max)) | ||
2018 | return EINA_FALSE; | ||
2019 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2020 | } | ||
2021 | else if (convert == EINA_VALUE_TYPE_INT) | ||
2022 | { | ||
2023 | int other_mem = v; | ||
2024 | if (EINA_UNLIKELY(v < eina_value_int_min)) | ||
2025 | return EINA_FALSE; | ||
2026 | if (EINA_UNLIKELY(v > eina_value_int_max)) | ||
2027 | return EINA_FALSE; | ||
2028 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2029 | } | ||
2030 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
2031 | { | ||
2032 | long other_mem = v; | ||
2033 | if (EINA_UNLIKELY(v < eina_value_long_min)) | ||
2034 | return EINA_FALSE; | ||
2035 | if (EINA_UNLIKELY(v > eina_value_long_max)) | ||
2036 | return EINA_FALSE; | ||
2037 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2038 | } | ||
2039 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
2040 | { | ||
2041 | int64_t other_mem = v; | ||
2042 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2043 | } | ||
2044 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
2045 | { | ||
2046 | float other_mem = v; | ||
2047 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2048 | } | ||
2049 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
2050 | { | ||
2051 | double other_mem = v; | ||
2052 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2053 | } | ||
2054 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
2055 | convert == EINA_VALUE_TYPE_STRING) | ||
2056 | { | ||
2057 | const char *other_mem; | ||
2058 | char buf[64]; | ||
2059 | snprintf(buf, sizeof(buf), "%g", (double)v); | ||
2060 | other_mem = buf; /* required due &buf == buf */ | ||
2061 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2062 | } | ||
2063 | else | ||
2064 | { | ||
2065 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2066 | return EINA_FALSE; | ||
2067 | } | ||
2068 | |||
2069 | return EINA_TRUE; | ||
2070 | } | ||
2071 | |||
2072 | static Eina_Bool | ||
2073 | _eina_value_type_double_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
2074 | { | ||
2075 | double *tmem = mem; | ||
2076 | *tmem = va_arg(args, double); | ||
2077 | return EINA_TRUE; | ||
2078 | } | ||
2079 | |||
2080 | static Eina_Bool | ||
2081 | _eina_value_type_double_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
2082 | { | ||
2083 | double *tmem = mem; | ||
2084 | const double *p = ptr; | ||
2085 | *tmem = *p; | ||
2086 | return EINA_TRUE; | ||
2087 | } | ||
2088 | |||
2089 | static Eina_Bool | ||
2090 | _eina_value_type_double_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
2091 | { | ||
2092 | const double *tmem = mem; | ||
2093 | double *p = ptr; | ||
2094 | *p = *tmem; | ||
2095 | return EINA_TRUE; | ||
2096 | } | ||
2097 | |||
2098 | static Eina_Bool | ||
2099 | _eina_value_type_string_common_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2100 | { | ||
2101 | const char **tmem = mem; | ||
2102 | *tmem = NULL; | ||
2103 | return EINA_TRUE; | ||
2104 | } | ||
2105 | |||
2106 | static int | ||
2107 | _eina_value_type_string_common_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
2108 | { | ||
2109 | const char *sa = *(const char **)a; | ||
2110 | const char *sb = *(const char **)b; | ||
2111 | if (sa == sb) | ||
2112 | return 0; | ||
2113 | if (sa == NULL) | ||
2114 | return -1; | ||
2115 | if (sb == NULL) | ||
2116 | return 1; | ||
2117 | return strcmp(sa, sb); | ||
2118 | } | ||
2119 | |||
2120 | static Eina_Bool | ||
2121 | _eina_value_type_string_common_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
2122 | { | ||
2123 | const char *v = *(const char **)type_mem; | ||
2124 | |||
2125 | eina_error_set(0); | ||
2126 | |||
2127 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
2128 | { | ||
2129 | unsigned char other_mem; | ||
2130 | if ((sscanf(v, "%hhu", &other_mem) != 1) && | ||
2131 | (sscanf(v, "%hhx", &other_mem) != 1) && | ||
2132 | (sscanf(v, "%hho", &other_mem) != 1)) | ||
2133 | return EINA_FALSE; | ||
2134 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2135 | } | ||
2136 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
2137 | { | ||
2138 | unsigned short other_mem; | ||
2139 | if ((sscanf(v, "%hu", &other_mem) != 1) && | ||
2140 | (sscanf(v, "%hx", &other_mem) != 1) && | ||
2141 | (sscanf(v, "%ho", &other_mem) != 1)) | ||
2142 | return EINA_FALSE; | ||
2143 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2144 | } | ||
2145 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
2146 | { | ||
2147 | unsigned int other_mem; | ||
2148 | if ((sscanf(v, "%u", &other_mem) != 1) && | ||
2149 | (sscanf(v, "%x", &other_mem) != 1) && | ||
2150 | (sscanf(v, "%o", &other_mem) != 1)) | ||
2151 | return EINA_FALSE; | ||
2152 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2153 | } | ||
2154 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
2155 | { | ||
2156 | unsigned long other_mem; | ||
2157 | if ((sscanf(v, "%lu", &other_mem) != 1) && | ||
2158 | (sscanf(v, "%lx", &other_mem) != 1) && | ||
2159 | (sscanf(v, "%lo", &other_mem) != 1)) | ||
2160 | return EINA_FALSE; | ||
2161 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2162 | } | ||
2163 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
2164 | { | ||
2165 | uint64_t other_mem; | ||
2166 | if ((sscanf(v, "%"SCNu64, &other_mem) != 1) && | ||
2167 | (sscanf(v, "%"SCNx64, &other_mem) != 1) && | ||
2168 | (sscanf(v, "%"SCNo64, &other_mem) != 1)) | ||
2169 | return EINA_FALSE; | ||
2170 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2171 | } | ||
2172 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
2173 | { | ||
2174 | char other_mem; | ||
2175 | if ((sscanf(v, "%hhd", &other_mem) != 1) && | ||
2176 | (sscanf(v, "%hhx", &other_mem) != 1) && | ||
2177 | (sscanf(v, "%hho", &other_mem) != 1)) | ||
2178 | return EINA_FALSE; | ||
2179 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2180 | } | ||
2181 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
2182 | { | ||
2183 | short other_mem; | ||
2184 | if ((sscanf(v, "%hd", &other_mem) != 1) && | ||
2185 | (sscanf(v, "%hx", &other_mem) != 1) && | ||
2186 | (sscanf(v, "%ho", &other_mem) != 1)) | ||
2187 | return EINA_FALSE; | ||
2188 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2189 | } | ||
2190 | else if (convert == EINA_VALUE_TYPE_INT) | ||
2191 | { | ||
2192 | int other_mem; | ||
2193 | if ((sscanf(v, "%d", &other_mem) != 1) && | ||
2194 | (sscanf(v, "%x", &other_mem) != 1) && | ||
2195 | (sscanf(v, "%o", &other_mem) != 1)) | ||
2196 | return EINA_FALSE; | ||
2197 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2198 | } | ||
2199 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
2200 | { | ||
2201 | long other_mem; | ||
2202 | if ((sscanf(v, "%ld", &other_mem) != 1) && | ||
2203 | (sscanf(v, "%lx", &other_mem) != 1) && | ||
2204 | (sscanf(v, "%lo", &other_mem) != 1)) | ||
2205 | return EINA_FALSE; | ||
2206 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2207 | } | ||
2208 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
2209 | { | ||
2210 | int64_t other_mem; | ||
2211 | if ((sscanf(v, "%"SCNd64, &other_mem) != 1) && | ||
2212 | (sscanf(v, "%"SCNx64, &other_mem) != 1) && | ||
2213 | (sscanf(v, "%"SCNo64, &other_mem) != 1)) | ||
2214 | return EINA_FALSE; | ||
2215 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2216 | } | ||
2217 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
2218 | { | ||
2219 | float other_mem; | ||
2220 | if (sscanf(v, "%f", &other_mem) != 1) | ||
2221 | return EINA_FALSE; | ||
2222 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2223 | } | ||
2224 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
2225 | { | ||
2226 | double other_mem; | ||
2227 | if (sscanf(v, "%lf", &other_mem) != 1) | ||
2228 | return EINA_FALSE; | ||
2229 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
2230 | } | ||
2231 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
2232 | convert == EINA_VALUE_TYPE_STRING) | ||
2233 | { | ||
2234 | return eina_value_type_pset(convert, convert_mem, &v); | ||
2235 | } | ||
2236 | else | ||
2237 | { | ||
2238 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2239 | return EINA_FALSE; | ||
2240 | } | ||
2241 | |||
2242 | return EINA_TRUE; | ||
2243 | } | ||
2244 | |||
2245 | static Eina_Bool | ||
2246 | _eina_value_type_string_common_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
2247 | { | ||
2248 | memcpy(ptr, mem, sizeof(const char *)); | ||
2249 | return EINA_TRUE; | ||
2250 | } | ||
2251 | |||
2252 | static Eina_Bool | ||
2253 | _eina_value_type_stringshare_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2254 | { | ||
2255 | const char **tmem = mem; | ||
2256 | if (*tmem) | ||
2257 | { | ||
2258 | eina_stringshare_del(*tmem); | ||
2259 | *tmem = NULL; | ||
2260 | } | ||
2261 | return EINA_TRUE; | ||
2262 | } | ||
2263 | |||
2264 | static Eina_Bool | ||
2265 | _eina_value_type_stringshare_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
2266 | { | ||
2267 | const char * const*s = src; | ||
2268 | const char **d = dst; | ||
2269 | *d = eina_stringshare_add(*s); | ||
2270 | return EINA_TRUE; | ||
2271 | } | ||
2272 | |||
2273 | static Eina_Bool | ||
2274 | _eina_value_type_stringshare_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
2275 | { | ||
2276 | const char *str = va_arg(args, const char *); | ||
2277 | return eina_stringshare_replace((const char **)mem, str); | ||
2278 | } | ||
2279 | |||
2280 | static Eina_Bool | ||
2281 | _eina_value_type_stringshare_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
2282 | { | ||
2283 | const char * const *str = ptr; | ||
2284 | return eina_stringshare_replace((const char **)mem, *str); | ||
2285 | } | ||
2286 | |||
2287 | static Eina_Bool | ||
2288 | _eina_value_type_string_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2289 | { | ||
2290 | char **tmem = mem; | ||
2291 | if (*tmem) | ||
2292 | { | ||
2293 | free(*tmem); | ||
2294 | *tmem = NULL; | ||
2295 | } | ||
2296 | return EINA_TRUE; | ||
2297 | } | ||
2298 | |||
2299 | static Eina_Bool | ||
2300 | _eina_value_type_string_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
2301 | { | ||
2302 | const char * const *s = src; | ||
2303 | char **d = dst; | ||
2304 | if (*s == NULL) | ||
2305 | *d = NULL; | ||
2306 | else | ||
2307 | { | ||
2308 | *d = strdup(*s); | ||
2309 | if (*d == NULL) | ||
2310 | { | ||
2311 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
2312 | return EINA_FALSE; | ||
2313 | } | ||
2314 | } | ||
2315 | return EINA_TRUE; | ||
2316 | } | ||
2317 | |||
2318 | static Eina_Bool | ||
2319 | _eina_value_type_string_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
2320 | { | ||
2321 | char **tmem = mem; | ||
2322 | const char *str = va_arg(args, const char *); | ||
2323 | eina_error_set(0); | ||
2324 | if (str == *tmem) return EINA_TRUE; | ||
2325 | if (!str) | ||
2326 | { | ||
2327 | free(*tmem); | ||
2328 | *tmem = NULL; | ||
2329 | } | ||
2330 | else | ||
2331 | { | ||
2332 | char *tmp = strdup(str); | ||
2333 | if (!tmp) | ||
2334 | { | ||
2335 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
2336 | return EINA_FALSE; | ||
2337 | } | ||
2338 | free(*tmem); | ||
2339 | *tmem = tmp; | ||
2340 | } | ||
2341 | return EINA_TRUE; | ||
2342 | } | ||
2343 | |||
2344 | static Eina_Bool | ||
2345 | _eina_value_type_string_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
2346 | { | ||
2347 | char **tmem = mem; | ||
2348 | const char * const *str = ptr; | ||
2349 | eina_error_set(0); | ||
2350 | if (*str == *tmem) return EINA_TRUE; | ||
2351 | if (!*str) | ||
2352 | { | ||
2353 | free(*tmem); | ||
2354 | *tmem = NULL; | ||
2355 | } | ||
2356 | else | ||
2357 | { | ||
2358 | char *tmp = strdup(*str); | ||
2359 | if (!tmp) | ||
2360 | { | ||
2361 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
2362 | return EINA_FALSE; | ||
2363 | } | ||
2364 | free(*tmem); | ||
2365 | *tmem = tmp; | ||
2366 | } | ||
2367 | return EINA_TRUE; | ||
2368 | } | ||
2369 | |||
2370 | static Eina_Bool | ||
2371 | _eina_value_type_array_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2372 | { | ||
2373 | memset(mem, 0, sizeof(Eina_Value_Array)); | ||
2374 | return EINA_TRUE; | ||
2375 | } | ||
2376 | |||
2377 | static Eina_Bool | ||
2378 | _eina_value_type_array_flush_elements(Eina_Value_Array *tmem) | ||
2379 | { | ||
2380 | const Eina_Value_Type *subtype = tmem->subtype; | ||
2381 | Eina_Bool ret = EINA_TRUE; | ||
2382 | unsigned char sz; | ||
2383 | char *ptr, *ptr_end; | ||
2384 | |||
2385 | if (!tmem->array) return EINA_TRUE; | ||
2386 | |||
2387 | sz = tmem->array->member_size; | ||
2388 | ptr = tmem->array->members; | ||
2389 | ptr_end = ptr + tmem->array->len * sz; | ||
2390 | |||
2391 | for (; ptr < ptr_end; ptr += sz) | ||
2392 | ret &= eina_value_type_flush(subtype, ptr); | ||
2393 | |||
2394 | eina_inarray_flush(tmem->array); | ||
2395 | return ret; | ||
2396 | } | ||
2397 | |||
2398 | static Eina_Bool | ||
2399 | _eina_value_type_array_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2400 | { | ||
2401 | Eina_Value_Array *tmem = mem; | ||
2402 | Eina_Bool ret =_eina_value_type_array_flush_elements(tmem); | ||
2403 | |||
2404 | if (tmem->array) eina_inarray_free(tmem->array); | ||
2405 | tmem->array = NULL; | ||
2406 | tmem->subtype = NULL; | ||
2407 | return ret; | ||
2408 | } | ||
2409 | |||
2410 | static Eina_Bool | ||
2411 | _eina_value_type_array_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
2412 | { | ||
2413 | const Eina_Value_Type *subtype; | ||
2414 | const Eina_Value_Array *s = src; | ||
2415 | Eina_Value_Array *d = dst; | ||
2416 | unsigned int i, count, sz; | ||
2417 | char *ptr, *ptr_end; | ||
2418 | |||
2419 | d->subtype = subtype = s->subtype; | ||
2420 | d->step = s->step; | ||
2421 | |||
2422 | if ((!s->array) || (!s->subtype)) | ||
2423 | { | ||
2424 | d->array = NULL; | ||
2425 | return EINA_TRUE; | ||
2426 | } | ||
2427 | |||
2428 | if (!subtype->copy) | ||
2429 | { | ||
2430 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2431 | return EINA_FALSE; | ||
2432 | } | ||
2433 | |||
2434 | d->array = eina_inarray_new(subtype->value_size, s->step); | ||
2435 | if (!d->array) | ||
2436 | return EINA_FALSE; | ||
2437 | |||
2438 | sz = s->array->member_size; | ||
2439 | |||
2440 | count = eina_inarray_count(s->array); | ||
2441 | ptr = s->array->members; | ||
2442 | ptr_end = ptr + (count * sz); | ||
2443 | |||
2444 | for (i = 0; ptr < ptr_end; ptr += sz, i++) | ||
2445 | { | ||
2446 | void *imem = eina_inarray_alloc_at(d->array, i, 1); | ||
2447 | if (!imem) goto error; | ||
2448 | if (!subtype->copy(subtype, ptr, imem)) | ||
2449 | { | ||
2450 | eina_inarray_pop(d->array); | ||
2451 | goto error; | ||
2452 | } | ||
2453 | } | ||
2454 | |||
2455 | return EINA_TRUE; | ||
2456 | |||
2457 | error: | ||
2458 | _eina_value_type_array_flush_elements(d); | ||
2459 | return EINA_FALSE; | ||
2460 | } | ||
2461 | |||
2462 | static int | ||
2463 | _eina_value_type_array_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
2464 | { | ||
2465 | const Eina_Value_Type *subtype; | ||
2466 | const Eina_Value_Array *eva_a = a, *eva_b = b; | ||
2467 | const char *a_ptr, *a_ptr_end, *b_ptr; | ||
2468 | unsigned int count_a, count_b, count, sz; | ||
2469 | int cmp = 0; | ||
2470 | |||
2471 | if (eva_a->subtype != eva_b->subtype) | ||
2472 | { | ||
2473 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2474 | return -1; | ||
2475 | } | ||
2476 | |||
2477 | subtype = eva_a->subtype; | ||
2478 | if (!subtype->compare) | ||
2479 | { | ||
2480 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2481 | return 0; | ||
2482 | } | ||
2483 | |||
2484 | if ((!eva_a->array) && (!eva_b->array)) | ||
2485 | return 0; | ||
2486 | else if (!eva_a->array) | ||
2487 | return -1; | ||
2488 | else if (!eva_b->array) | ||
2489 | return 1; | ||
2490 | |||
2491 | count_a = eina_inarray_count(eva_a->array); | ||
2492 | count_b = eina_inarray_count(eva_b->array); | ||
2493 | |||
2494 | if (count_a <= count_b) | ||
2495 | count = count_a; | ||
2496 | else | ||
2497 | count = count_b; | ||
2498 | |||
2499 | sz = eva_a->array->member_size; | ||
2500 | |||
2501 | a_ptr = eva_a->array->members; | ||
2502 | a_ptr_end = a_ptr + (count * sz); | ||
2503 | b_ptr = eva_b->array->members; | ||
2504 | |||
2505 | for (; (cmp == 0) && (a_ptr < a_ptr_end); a_ptr += sz, b_ptr += sz) | ||
2506 | cmp = subtype->compare(subtype, a_ptr, b_ptr); | ||
2507 | |||
2508 | if (cmp == 0) | ||
2509 | { | ||
2510 | if (count_a < count_b) | ||
2511 | return -1; | ||
2512 | else if (count_a > count_b) | ||
2513 | return 1; | ||
2514 | return 0; | ||
2515 | } | ||
2516 | |||
2517 | return cmp; | ||
2518 | } | ||
2519 | |||
2520 | static Eina_Bool | ||
2521 | _eina_value_type_array_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
2522 | { | ||
2523 | const Eina_Value_Array *tmem = type_mem; | ||
2524 | Eina_Bool ret = EINA_FALSE; | ||
2525 | |||
2526 | if ((convert == EINA_VALUE_TYPE_STRING) || | ||
2527 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | ||
2528 | { | ||
2529 | Eina_Strbuf *str = eina_strbuf_new(); | ||
2530 | const char *ptr; | ||
2531 | if (!tmem->array) eina_strbuf_append(str, "[]"); | ||
2532 | else | ||
2533 | { | ||
2534 | const Eina_Value_Type *subtype = tmem->subtype; | ||
2535 | unsigned char sz; | ||
2536 | const char *ptr_end; | ||
2537 | Eina_Value tmp; | ||
2538 | Eina_Bool first = EINA_TRUE; | ||
2539 | |||
2540 | eina_value_setup(&tmp, EINA_VALUE_TYPE_STRING); | ||
2541 | |||
2542 | eina_strbuf_append_char(str, '['); | ||
2543 | |||
2544 | sz = tmem->array->member_size; | ||
2545 | ptr = tmem->array->members; | ||
2546 | ptr_end = ptr + tmem->array->len * sz; | ||
2547 | for (; ptr < ptr_end; ptr += sz) | ||
2548 | { | ||
2549 | Eina_Bool r = EINA_FALSE; | ||
2550 | if (subtype->convert_to) | ||
2551 | { | ||
2552 | r = subtype->convert_to(subtype, EINA_VALUE_TYPE_STRING, | ||
2553 | ptr, tmp.value.buf); | ||
2554 | if (r) | ||
2555 | { | ||
2556 | if (first) first = EINA_FALSE; | ||
2557 | else eina_strbuf_append_length(str, ", ", 2); | ||
2558 | eina_strbuf_append(str, tmp.value.ptr); | ||
2559 | free(tmp.value.ptr); | ||
2560 | tmp.value.ptr = NULL; | ||
2561 | } | ||
2562 | } | ||
2563 | |||
2564 | if (!r) | ||
2565 | { | ||
2566 | if (first) | ||
2567 | { | ||
2568 | first = EINA_FALSE; | ||
2569 | eina_strbuf_append_char(str, '?'); | ||
2570 | } | ||
2571 | else | ||
2572 | eina_strbuf_append_length(str, ", ?", 3); | ||
2573 | } | ||
2574 | } | ||
2575 | |||
2576 | eina_strbuf_append_char(str, ']'); | ||
2577 | } | ||
2578 | ptr = eina_strbuf_string_get(str); | ||
2579 | ret = eina_value_type_pset(convert, convert_mem, &ptr); | ||
2580 | eina_strbuf_free(str); | ||
2581 | } | ||
2582 | else if ((tmem->array) && (tmem->array->len == 1)) | ||
2583 | { | ||
2584 | const Eina_Value_Type *subtype = tmem->subtype; | ||
2585 | void *imem = tmem->array->members; | ||
2586 | |||
2587 | if (subtype->convert_to) | ||
2588 | ret = subtype->convert_to(subtype, convert, imem, convert_mem); | ||
2589 | if ((!ret) && (convert->convert_from)) | ||
2590 | ret = convert->convert_from(convert, subtype, convert_mem, imem); | ||
2591 | } | ||
2592 | |||
2593 | if (!ret) | ||
2594 | { | ||
2595 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2596 | return EINA_FALSE; | ||
2597 | } | ||
2598 | return EINA_TRUE; | ||
2599 | } | ||
2600 | |||
2601 | static Eina_Bool | ||
2602 | _eina_value_type_array_convert_from(const Eina_Value_Type *type, const Eina_Value_Type *convert, void *type_mem, const void *convert_mem) | ||
2603 | { | ||
2604 | Eina_Value_Array *tmem = type_mem; | ||
2605 | Eina_Value_Array desc = {convert, tmem->step, NULL}; | ||
2606 | char *buf; | ||
2607 | void *imem; | ||
2608 | |||
2609 | if (!eina_value_type_pset(type, tmem, &desc)) | ||
2610 | return EINA_FALSE; | ||
2611 | |||
2612 | buf = alloca(convert->value_size); | ||
2613 | if (!eina_value_type_pget(convert, convert_mem, &buf)) | ||
2614 | return EINA_FALSE; | ||
2615 | |||
2616 | imem = eina_inarray_alloc_at(tmem->array, 0, 1); | ||
2617 | if (!imem) | ||
2618 | return EINA_FALSE; | ||
2619 | |||
2620 | if (!eina_value_type_setup(convert, imem)) goto error_setup; | ||
2621 | if (!eina_value_type_pset(convert, imem, &buf)) goto error_set; | ||
2622 | return EINA_TRUE; | ||
2623 | |||
2624 | error_set: | ||
2625 | eina_value_type_flush(convert, imem); | ||
2626 | error_setup: | ||
2627 | eina_inarray_remove_at(tmem->array, 0); | ||
2628 | return EINA_FALSE; | ||
2629 | } | ||
2630 | |||
2631 | static Eina_Bool | ||
2632 | _eina_value_type_array_pset(const Eina_Value_Type *type, void *mem, const void *ptr) | ||
2633 | { | ||
2634 | Eina_Value_Array *tmem = mem; | ||
2635 | const Eina_Value_Array *desc = ptr; | ||
2636 | Eina_Inarray *desc_array; | ||
2637 | |||
2638 | eina_error_set(0); | ||
2639 | if ((!tmem->subtype) && (!desc->subtype)) | ||
2640 | return EINA_TRUE; | ||
2641 | |||
2642 | desc_array = desc->array; | ||
2643 | if (desc_array) | ||
2644 | { | ||
2645 | Eina_Value_Array tmp; | ||
2646 | |||
2647 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
2648 | (desc_array->member_size == desc->subtype->value_size, EINA_FALSE); | ||
2649 | |||
2650 | if (desc_array == tmem->array) | ||
2651 | { | ||
2652 | tmem->subtype = desc->subtype; | ||
2653 | return EINA_TRUE; | ||
2654 | } | ||
2655 | |||
2656 | if (!_eina_value_type_array_copy(type, desc, &tmp)) | ||
2657 | return EINA_FALSE; | ||
2658 | |||
2659 | _eina_value_type_array_flush(type, tmem); | ||
2660 | memcpy(tmem, &tmp, sizeof(tmp)); | ||
2661 | return EINA_TRUE; | ||
2662 | } | ||
2663 | |||
2664 | if (tmem->array) | ||
2665 | { | ||
2666 | _eina_value_type_array_flush_elements(tmem); | ||
2667 | eina_inarray_setup(tmem->array, desc->subtype->value_size, desc->step); | ||
2668 | } | ||
2669 | else | ||
2670 | { | ||
2671 | tmem->array = eina_inarray_new(desc->subtype->value_size, desc->step); | ||
2672 | if (!tmem->array) | ||
2673 | return EINA_FALSE; | ||
2674 | } | ||
2675 | |||
2676 | tmem->subtype = desc->subtype; | ||
2677 | return EINA_TRUE; | ||
2678 | } | ||
2679 | |||
2680 | static Eina_Bool | ||
2681 | _eina_value_type_array_vset(const Eina_Value_Type *type, void *mem, va_list args) | ||
2682 | { | ||
2683 | const Eina_Value_Array desc = va_arg(args, Eina_Value_Array); | ||
2684 | _eina_value_type_array_pset(type, mem, &desc); | ||
2685 | return EINA_TRUE; | ||
2686 | } | ||
2687 | |||
2688 | static Eina_Bool | ||
2689 | _eina_value_type_array_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
2690 | { | ||
2691 | memcpy(ptr, mem, sizeof(Eina_Value_Array)); | ||
2692 | return EINA_TRUE; | ||
2693 | } | ||
2694 | |||
2695 | static const Eina_Value_Type _EINA_VALUE_TYPE_ARRAY = { | ||
2696 | EINA_VALUE_TYPE_VERSION, | ||
2697 | sizeof(Eina_Value_Array), | ||
2698 | "Eina_Value_Array", | ||
2699 | _eina_value_type_array_setup, | ||
2700 | _eina_value_type_array_flush, | ||
2701 | _eina_value_type_array_copy, | ||
2702 | _eina_value_type_array_compare, | ||
2703 | _eina_value_type_array_convert_to, | ||
2704 | _eina_value_type_array_convert_from, | ||
2705 | _eina_value_type_array_vset, | ||
2706 | _eina_value_type_array_pset, | ||
2707 | _eina_value_type_array_pget | ||
2708 | }; | ||
2709 | |||
2710 | static Eina_Bool | ||
2711 | _eina_value_type_list_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2712 | { | ||
2713 | memset(mem, 0, sizeof(Eina_Value_List)); | ||
2714 | return EINA_TRUE; | ||
2715 | } | ||
2716 | |||
2717 | static Eina_Bool | ||
2718 | _eina_value_type_list_flush_elements(Eina_Value_List *tmem) | ||
2719 | { | ||
2720 | const Eina_Value_Type *subtype = tmem->subtype; | ||
2721 | Eina_Bool ret = EINA_TRUE; | ||
2722 | |||
2723 | if (!tmem->list) return EINA_TRUE; | ||
2724 | |||
2725 | while (tmem->list) | ||
2726 | { | ||
2727 | void *mem = eina_value_list_node_memory_get(tmem->subtype, tmem->list); | ||
2728 | ret &= eina_value_type_flush(subtype, mem); | ||
2729 | eina_value_list_node_memory_flush(tmem->subtype, tmem->list); | ||
2730 | tmem->list = eina_list_remove_list(tmem->list, tmem->list); | ||
2731 | } | ||
2732 | |||
2733 | return ret; | ||
2734 | } | ||
2735 | |||
2736 | static Eina_Bool | ||
2737 | _eina_value_type_list_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
2738 | { | ||
2739 | Eina_Value_List *tmem = mem; | ||
2740 | Eina_Bool ret =_eina_value_type_list_flush_elements(tmem); | ||
2741 | |||
2742 | if (tmem->list) eina_list_free(tmem->list); | ||
2743 | tmem->list = NULL; | ||
2744 | tmem->subtype = NULL; | ||
2745 | return ret; | ||
2746 | } | ||
2747 | |||
2748 | static Eina_Bool | ||
2749 | _eina_value_type_list_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
2750 | { | ||
2751 | const Eina_Value_Type *subtype; | ||
2752 | const Eina_Value_List *s = src; | ||
2753 | Eina_Value_List *d = dst; | ||
2754 | const Eina_List *snode; | ||
2755 | |||
2756 | d->subtype = subtype = s->subtype; | ||
2757 | if ((!s->list) || (!s->subtype)) | ||
2758 | { | ||
2759 | d->list = NULL; | ||
2760 | return EINA_TRUE; | ||
2761 | } | ||
2762 | |||
2763 | if (!subtype->copy) | ||
2764 | { | ||
2765 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2766 | return EINA_FALSE; | ||
2767 | } | ||
2768 | |||
2769 | d->list = NULL; | ||
2770 | for (snode = s->list; snode != NULL; snode = snode->next) | ||
2771 | { | ||
2772 | const void *ptr = eina_value_list_node_memory_get(subtype, snode); | ||
2773 | Eina_List *dnode; | ||
2774 | void *imem; | ||
2775 | |||
2776 | d->list = eina_list_append(d->list, (void*)1L); | ||
2777 | dnode = eina_list_last(d->list); | ||
2778 | EINA_SAFETY_ON_NULL_GOTO(dnode, error); | ||
2779 | EINA_SAFETY_ON_FALSE_GOTO(dnode->data == (void*)1L, error); | ||
2780 | |||
2781 | imem = eina_value_list_node_memory_setup(subtype, dnode); | ||
2782 | if (!subtype->copy(subtype, ptr, imem)) | ||
2783 | { | ||
2784 | eina_value_list_node_memory_flush(subtype, dnode); | ||
2785 | d->list = eina_list_remove_list(d->list, dnode); | ||
2786 | goto error; | ||
2787 | } | ||
2788 | } | ||
2789 | return EINA_TRUE; | ||
2790 | |||
2791 | error: | ||
2792 | _eina_value_type_list_flush_elements(d); | ||
2793 | return EINA_FALSE; | ||
2794 | } | ||
2795 | |||
2796 | static int | ||
2797 | _eina_value_type_list_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
2798 | { | ||
2799 | const Eina_Value_Type *subtype; | ||
2800 | const Eina_Value_List *eva_a = a, *eva_b = b; | ||
2801 | const Eina_List *anode, *bnode; | ||
2802 | int cmp = 0; | ||
2803 | |||
2804 | if (eva_a->subtype != eva_b->subtype) | ||
2805 | { | ||
2806 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2807 | return -1; | ||
2808 | } | ||
2809 | |||
2810 | subtype = eva_a->subtype; | ||
2811 | if (!subtype->compare) | ||
2812 | { | ||
2813 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2814 | return 0; | ||
2815 | } | ||
2816 | |||
2817 | if ((!eva_a->list) && (!eva_b->list)) | ||
2818 | return 0; | ||
2819 | else if (!eva_a->list) | ||
2820 | return -1; | ||
2821 | else if (!eva_b->list) | ||
2822 | return 1; | ||
2823 | |||
2824 | for (anode = eva_a->list, bnode = eva_b->list; | ||
2825 | (cmp == 0) && (anode) && (bnode); | ||
2826 | anode = anode->next, bnode = bnode->next) | ||
2827 | { | ||
2828 | const void *amem = eina_value_list_node_memory_get(subtype, anode); | ||
2829 | const void *bmem = eina_value_list_node_memory_get(subtype, bnode); | ||
2830 | cmp = subtype->compare(subtype, amem, bmem); | ||
2831 | } | ||
2832 | |||
2833 | if (cmp == 0) | ||
2834 | { | ||
2835 | if ((!anode) && (bnode)) | ||
2836 | return -1; | ||
2837 | else if ((anode) && (!bnode)) | ||
2838 | return 1; | ||
2839 | return 0; | ||
2840 | } | ||
2841 | |||
2842 | return cmp; | ||
2843 | } | ||
2844 | |||
2845 | static Eina_Bool | ||
2846 | _eina_value_type_list_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
2847 | { | ||
2848 | const Eina_Value_List *tmem = type_mem; | ||
2849 | Eina_Bool ret = EINA_FALSE; | ||
2850 | |||
2851 | if ((convert == EINA_VALUE_TYPE_STRING) || | ||
2852 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | ||
2853 | { | ||
2854 | Eina_Strbuf *str = eina_strbuf_new(); | ||
2855 | const char *s; | ||
2856 | if (!tmem->list) eina_strbuf_append(str, "[]"); | ||
2857 | else | ||
2858 | { | ||
2859 | const Eina_Value_Type *subtype = tmem->subtype; | ||
2860 | const Eina_List *node; | ||
2861 | Eina_Value tmp; | ||
2862 | Eina_Bool first = EINA_TRUE; | ||
2863 | |||
2864 | eina_value_setup(&tmp, EINA_VALUE_TYPE_STRING); | ||
2865 | |||
2866 | eina_strbuf_append_char(str, '['); | ||
2867 | |||
2868 | for (node = tmem->list; node != NULL; node = node->next) | ||
2869 | { | ||
2870 | Eina_Bool r = EINA_FALSE; | ||
2871 | |||
2872 | if (subtype->convert_to) | ||
2873 | { | ||
2874 | const void *ptr; | ||
2875 | ptr = eina_value_list_node_memory_get(subtype, node); | ||
2876 | r = subtype->convert_to(subtype, EINA_VALUE_TYPE_STRING, | ||
2877 | ptr, tmp.value.buf); | ||
2878 | if (r) | ||
2879 | { | ||
2880 | if (first) first = EINA_FALSE; | ||
2881 | else eina_strbuf_append_length(str, ", ", 2); | ||
2882 | eina_strbuf_append(str, tmp.value.ptr); | ||
2883 | free(tmp.value.ptr); | ||
2884 | tmp.value.ptr = NULL; | ||
2885 | } | ||
2886 | } | ||
2887 | |||
2888 | if (!r) | ||
2889 | { | ||
2890 | if (first) | ||
2891 | { | ||
2892 | first = EINA_FALSE; | ||
2893 | eina_strbuf_append_char(str, '?'); | ||
2894 | } | ||
2895 | else | ||
2896 | eina_strbuf_append_length(str, ", ?", 3); | ||
2897 | } | ||
2898 | } | ||
2899 | |||
2900 | eina_strbuf_append_char(str, ']'); | ||
2901 | } | ||
2902 | s = eina_strbuf_string_get(str); | ||
2903 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
2904 | eina_strbuf_free(str); | ||
2905 | } | ||
2906 | else if ((tmem->list) && (tmem->list->next == NULL)) | ||
2907 | { | ||
2908 | const Eina_Value_Type *subtype = tmem->subtype; | ||
2909 | void *imem = eina_value_list_node_memory_get(subtype, tmem->list); | ||
2910 | |||
2911 | if (subtype->convert_to) | ||
2912 | ret = subtype->convert_to(subtype, convert, imem, convert_mem); | ||
2913 | if ((!ret) && (convert->convert_from)) | ||
2914 | ret = convert->convert_from(convert, subtype, convert_mem, imem); | ||
2915 | } | ||
2916 | |||
2917 | if (!ret) | ||
2918 | { | ||
2919 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
2920 | return EINA_FALSE; | ||
2921 | } | ||
2922 | return EINA_TRUE; | ||
2923 | } | ||
2924 | |||
2925 | static Eina_Bool | ||
2926 | _eina_value_type_list_convert_from(const Eina_Value_Type *type, const Eina_Value_Type *convert, void *type_mem, const void *convert_mem) | ||
2927 | { | ||
2928 | Eina_Value_List *tmem = type_mem; | ||
2929 | Eina_Value_List desc = {convert, NULL}; | ||
2930 | Eina_List *node; | ||
2931 | char *buf; | ||
2932 | void *imem; | ||
2933 | |||
2934 | if (!eina_value_type_pset(type, tmem, &desc)) | ||
2935 | return EINA_FALSE; | ||
2936 | |||
2937 | buf = alloca(convert->value_size); | ||
2938 | if (!eina_value_type_pget(convert, convert_mem, &buf)) | ||
2939 | return EINA_FALSE; | ||
2940 | |||
2941 | tmem->list = eina_list_append(tmem->list, (void*)1L); | ||
2942 | node = eina_list_last(tmem->list); | ||
2943 | EINA_SAFETY_ON_NULL_RETURN_VAL(node, EINA_FALSE); | ||
2944 | EINA_SAFETY_ON_FALSE_RETURN_VAL(node->data == (void*)1L, EINA_FALSE); | ||
2945 | |||
2946 | imem = eina_value_list_node_memory_setup(tmem->subtype, node); | ||
2947 | if (!imem) | ||
2948 | { | ||
2949 | tmem->list = eina_list_remove_list(tmem->list, node); | ||
2950 | return EINA_FALSE; | ||
2951 | } | ||
2952 | |||
2953 | if (!eina_value_type_setup(tmem->subtype, imem)) goto error_setup; | ||
2954 | if (!eina_value_type_pset(tmem->subtype, imem, &buf)) goto error_set; | ||
2955 | return EINA_TRUE; | ||
2956 | |||
2957 | error_set: | ||
2958 | eina_value_type_flush(tmem->subtype, imem); | ||
2959 | error_setup: | ||
2960 | eina_value_list_node_memory_flush(tmem->subtype, node); | ||
2961 | tmem->list = eina_list_remove_list(tmem->list, node); | ||
2962 | return EINA_FALSE; | ||
2963 | } | ||
2964 | |||
2965 | static Eina_Bool | ||
2966 | _eina_value_type_list_pset(const Eina_Value_Type *type, void *mem, const void *ptr) | ||
2967 | { | ||
2968 | Eina_Value_List *tmem = mem; | ||
2969 | const Eina_Value_List *desc = ptr; | ||
2970 | |||
2971 | eina_error_set(0); | ||
2972 | if ((!tmem->subtype) && (!desc->subtype)) | ||
2973 | return EINA_TRUE; | ||
2974 | |||
2975 | if ((tmem->list) && (tmem->list == desc->list)) | ||
2976 | { | ||
2977 | tmem->subtype = desc->subtype; | ||
2978 | return EINA_TRUE; | ||
2979 | } | ||
2980 | |||
2981 | if (desc->list) | ||
2982 | { | ||
2983 | Eina_Value_List tmp; | ||
2984 | |||
2985 | if (!_eina_value_type_list_copy(type, desc, &tmp)) | ||
2986 | return EINA_FALSE; | ||
2987 | |||
2988 | _eina_value_type_list_flush(type, tmem); | ||
2989 | memcpy(tmem, &tmp, sizeof(tmp)); | ||
2990 | return EINA_TRUE; | ||
2991 | } | ||
2992 | |||
2993 | _eina_value_type_list_flush_elements(tmem); | ||
2994 | |||
2995 | tmem->subtype = desc->subtype; | ||
2996 | return EINA_TRUE; | ||
2997 | } | ||
2998 | |||
2999 | static Eina_Bool | ||
3000 | _eina_value_type_list_vset(const Eina_Value_Type *type, void *mem, va_list args) | ||
3001 | { | ||
3002 | const Eina_Value_List desc = va_arg(args, Eina_Value_List); | ||
3003 | _eina_value_type_list_pset(type, mem, &desc); | ||
3004 | return EINA_TRUE; | ||
3005 | } | ||
3006 | |||
3007 | static Eina_Bool | ||
3008 | _eina_value_type_list_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
3009 | { | ||
3010 | memcpy(ptr, mem, sizeof(Eina_Value_List)); | ||
3011 | return EINA_TRUE; | ||
3012 | } | ||
3013 | |||
3014 | static const Eina_Value_Type _EINA_VALUE_TYPE_LIST = { | ||
3015 | EINA_VALUE_TYPE_VERSION, | ||
3016 | sizeof(Eina_Value_List), | ||
3017 | "Eina_Value_List", | ||
3018 | _eina_value_type_list_setup, | ||
3019 | _eina_value_type_list_flush, | ||
3020 | _eina_value_type_list_copy, | ||
3021 | _eina_value_type_list_compare, | ||
3022 | _eina_value_type_list_convert_to, | ||
3023 | _eina_value_type_list_convert_from, | ||
3024 | _eina_value_type_list_vset, | ||
3025 | _eina_value_type_list_pset, | ||
3026 | _eina_value_type_list_pget | ||
3027 | }; | ||
3028 | |||
3029 | static Eina_Bool | ||
3030 | _eina_value_type_hash_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
3031 | { | ||
3032 | memset(mem, 0, sizeof(Eina_Value_Hash)); | ||
3033 | return EINA_TRUE; | ||
3034 | } | ||
3035 | |||
3036 | struct _eina_value_type_hash_flush_each_ctx | ||
3037 | { | ||
3038 | const Eina_Value_Type *subtype; | ||
3039 | Eina_Bool ret; | ||
3040 | }; | ||
3041 | |||
3042 | static Eina_Bool | ||
3043 | _eina_value_type_hash_flush_each(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *mem, void *user_data) | ||
3044 | { | ||
3045 | struct _eina_value_type_hash_flush_each_ctx *ctx = user_data; | ||
3046 | ctx->ret &= eina_value_type_flush(ctx->subtype, mem); | ||
3047 | free(mem); | ||
3048 | return EINA_TRUE; | ||
3049 | } | ||
3050 | |||
3051 | static Eina_Bool | ||
3052 | _eina_value_type_hash_flush_elements(Eina_Value_Hash *tmem) | ||
3053 | { | ||
3054 | struct _eina_value_type_hash_flush_each_ctx ctx = { | ||
3055 | tmem->subtype, | ||
3056 | EINA_TRUE | ||
3057 | }; | ||
3058 | |||
3059 | if (!tmem->hash) return EINA_TRUE; | ||
3060 | |||
3061 | eina_hash_foreach(tmem->hash, _eina_value_type_hash_flush_each, &ctx); | ||
3062 | eina_hash_free(tmem->hash); | ||
3063 | tmem->hash = NULL; | ||
3064 | return ctx.ret; | ||
3065 | } | ||
3066 | |||
3067 | static Eina_Bool | ||
3068 | _eina_value_type_hash_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
3069 | { | ||
3070 | Eina_Value_Hash *tmem = mem; | ||
3071 | Eina_Bool ret =_eina_value_type_hash_flush_elements(tmem); | ||
3072 | tmem->subtype = NULL; | ||
3073 | return ret; | ||
3074 | } | ||
3075 | |||
3076 | static unsigned int | ||
3077 | _eina_value_hash_key_length(const void *key) | ||
3078 | { | ||
3079 | if (!key) | ||
3080 | return 0; | ||
3081 | return (int)strlen(key) + 1; | ||
3082 | } | ||
3083 | |||
3084 | static int | ||
3085 | _eina_value_hash_key_cmp(const void *key1, int key1_len, const void *key2, int key2_len) | ||
3086 | { | ||
3087 | int r = key1_len - key2_len; | ||
3088 | if (r != 0) | ||
3089 | return r; | ||
3090 | return strcmp(key1, key2); | ||
3091 | } | ||
3092 | |||
3093 | static Eina_Bool | ||
3094 | _eina_value_type_hash_create(Eina_Value_Hash *desc) | ||
3095 | { | ||
3096 | if (!desc->buckets_power_size) | ||
3097 | desc->buckets_power_size = 5; | ||
3098 | |||
3099 | desc->hash = eina_hash_new(_eina_value_hash_key_length, | ||
3100 | _eina_value_hash_key_cmp, | ||
3101 | EINA_KEY_HASH(eina_hash_superfast), | ||
3102 | NULL, desc->buckets_power_size); | ||
3103 | return !!desc->hash; | ||
3104 | } | ||
3105 | |||
3106 | struct _eina_value_type_hash_copy_each_ctx | ||
3107 | { | ||
3108 | const Eina_Value_Type *subtype; | ||
3109 | Eina_Value_Hash *dest; | ||
3110 | Eina_Bool ret; | ||
3111 | }; | ||
3112 | |||
3113 | static Eina_Bool | ||
3114 | _eina_value_type_hash_copy_each(const Eina_Hash *hash __UNUSED__, const void *key, void *_ptr, void *user_data) | ||
3115 | { | ||
3116 | struct _eina_value_type_hash_copy_each_ctx *ctx = user_data; | ||
3117 | const void *ptr = _ptr; | ||
3118 | void *imem = malloc(ctx->subtype->value_size); | ||
3119 | if (!imem) | ||
3120 | { | ||
3121 | ctx->ret = EINA_FALSE; | ||
3122 | return EINA_FALSE; | ||
3123 | } | ||
3124 | if (!ctx->subtype->copy(ctx->subtype, ptr, imem)) | ||
3125 | { | ||
3126 | free(imem); | ||
3127 | ctx->ret = EINA_FALSE; | ||
3128 | return EINA_FALSE; | ||
3129 | } | ||
3130 | if (!eina_hash_add(ctx->dest->hash, key, imem)) | ||
3131 | { | ||
3132 | eina_value_type_flush(ctx->subtype, imem); | ||
3133 | free(imem); | ||
3134 | ctx->ret = EINA_FALSE; | ||
3135 | return EINA_FALSE; | ||
3136 | } | ||
3137 | return EINA_TRUE; | ||
3138 | } | ||
3139 | |||
3140 | static Eina_Bool | ||
3141 | _eina_value_type_hash_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
3142 | { | ||
3143 | const Eina_Value_Hash *s = src; | ||
3144 | Eina_Value_Hash *d = dst; | ||
3145 | struct _eina_value_type_hash_copy_each_ctx ctx = {s->subtype, d, EINA_TRUE}; | ||
3146 | |||
3147 | d->subtype = s->subtype; | ||
3148 | d->buckets_power_size = s->buckets_power_size; | ||
3149 | |||
3150 | if ((!s->hash) || (!s->subtype)) | ||
3151 | { | ||
3152 | d->hash = NULL; | ||
3153 | return EINA_TRUE; | ||
3154 | } | ||
3155 | |||
3156 | if (!s->subtype->copy) | ||
3157 | { | ||
3158 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3159 | return EINA_FALSE; | ||
3160 | } | ||
3161 | |||
3162 | if (!_eina_value_type_hash_create(d)) | ||
3163 | return EINA_FALSE; | ||
3164 | |||
3165 | eina_hash_foreach(s->hash, _eina_value_type_hash_copy_each, &ctx); | ||
3166 | if (!ctx.ret) | ||
3167 | { | ||
3168 | _eina_value_type_hash_flush_elements(d); | ||
3169 | return EINA_FALSE; | ||
3170 | } | ||
3171 | return EINA_TRUE; | ||
3172 | } | ||
3173 | |||
3174 | struct _eina_value_type_hash_compare_each_ctx | ||
3175 | { | ||
3176 | const Eina_Value_Type *subtype; | ||
3177 | const Eina_Hash *other; | ||
3178 | int cmp; | ||
3179 | }; | ||
3180 | |||
3181 | static Eina_Bool | ||
3182 | _eina_value_type_hash_compare_each(const Eina_Hash *hash __UNUSED__, const void *key, void *_ptr, void *user_data) | ||
3183 | { | ||
3184 | struct _eina_value_type_hash_compare_each_ctx *ctx = user_data; | ||
3185 | const void *self_ptr = _ptr; | ||
3186 | const void *other_ptr = eina_hash_find(ctx->other, key); | ||
3187 | if (!other_ptr) return EINA_TRUE; | ||
3188 | ctx->cmp = ctx->subtype->compare(ctx->subtype, self_ptr, other_ptr); | ||
3189 | return ctx->cmp == 0; | ||
3190 | } | ||
3191 | |||
3192 | static int | ||
3193 | _eina_value_type_hash_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
3194 | { | ||
3195 | const Eina_Value_Hash *eva_a = a, *eva_b = b; | ||
3196 | struct _eina_value_type_hash_compare_each_ctx ctx = { | ||
3197 | eva_a->subtype, eva_b->hash, 0 | ||
3198 | }; | ||
3199 | |||
3200 | if (eva_a->subtype != eva_b->subtype) | ||
3201 | { | ||
3202 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3203 | return -1; | ||
3204 | } | ||
3205 | |||
3206 | if (!eva_a->subtype->compare) | ||
3207 | { | ||
3208 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3209 | return 0; | ||
3210 | } | ||
3211 | |||
3212 | if ((!eva_a->hash) && (!eva_b->hash)) | ||
3213 | return 0; | ||
3214 | else if (!eva_a->hash) | ||
3215 | return -1; | ||
3216 | else if (!eva_b->hash) | ||
3217 | return 1; | ||
3218 | |||
3219 | eina_hash_foreach(eva_a->hash, _eina_value_type_hash_compare_each, &ctx); | ||
3220 | if (ctx.cmp == 0) | ||
3221 | { | ||
3222 | unsigned int count_a = eina_hash_population(eva_a->hash); | ||
3223 | unsigned int count_b = eina_hash_population(eva_b->hash); | ||
3224 | if (count_a < count_b) | ||
3225 | return -1; | ||
3226 | else if (count_a > count_b) | ||
3227 | return 1; | ||
3228 | return 0; | ||
3229 | } | ||
3230 | |||
3231 | return ctx.cmp; | ||
3232 | } | ||
3233 | |||
3234 | static Eina_Bool | ||
3235 | _eina_value_type_hash_find_first(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *ptr, void *user_data) | ||
3236 | { | ||
3237 | void **ret = user_data; | ||
3238 | *ret = ptr; | ||
3239 | return EINA_FALSE; | ||
3240 | } | ||
3241 | |||
3242 | struct _eina_value_type_hash_convert_to_string_each_ctx | ||
3243 | { | ||
3244 | const Eina_Value_Type *subtype; | ||
3245 | Eina_Strbuf *str; | ||
3246 | Eina_Value tmp; | ||
3247 | Eina_Bool first; | ||
3248 | }; | ||
3249 | |||
3250 | static Eina_Bool | ||
3251 | _eina_value_type_hash_convert_to_string_each(const Eina_Hash *hash __UNUSED__, const void *_key, void *_ptr, void *user_data) | ||
3252 | { | ||
3253 | struct _eina_value_type_hash_convert_to_string_each_ctx *ctx = user_data; | ||
3254 | const char *key = _key; | ||
3255 | const void *ptr = _ptr; | ||
3256 | Eina_Bool r = EINA_FALSE; | ||
3257 | |||
3258 | if (ctx->first) ctx->first = EINA_FALSE; | ||
3259 | else eina_strbuf_append_length(ctx->str, ", ", 2); | ||
3260 | |||
3261 | eina_strbuf_append(ctx->str, key); | ||
3262 | eina_strbuf_append_length(ctx->str, ": ", 2); | ||
3263 | |||
3264 | if (ctx->subtype->convert_to) | ||
3265 | { | ||
3266 | r = ctx->subtype->convert_to(ctx->subtype, EINA_VALUE_TYPE_STRING, | ||
3267 | ptr, ctx->tmp.value.buf); | ||
3268 | if (r) | ||
3269 | { | ||
3270 | eina_strbuf_append(ctx->str, ctx->tmp.value.ptr); | ||
3271 | free(ctx->tmp.value.ptr); | ||
3272 | ctx->tmp.value.ptr = NULL; | ||
3273 | } | ||
3274 | } | ||
3275 | |||
3276 | if (!r) | ||
3277 | eina_strbuf_append_char(ctx->str, '?'); | ||
3278 | |||
3279 | return EINA_TRUE; | ||
3280 | } | ||
3281 | |||
3282 | static Eina_Bool | ||
3283 | _eina_value_type_hash_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
3284 | { | ||
3285 | const Eina_Value_Hash *tmem = type_mem; | ||
3286 | Eina_Bool ret = EINA_FALSE; | ||
3287 | |||
3288 | if ((convert == EINA_VALUE_TYPE_STRING) || | ||
3289 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | ||
3290 | { | ||
3291 | Eina_Strbuf *str = eina_strbuf_new(); | ||
3292 | const char *s; | ||
3293 | if (!tmem->hash) eina_strbuf_append(str, "{}"); | ||
3294 | else | ||
3295 | { | ||
3296 | struct _eina_value_type_hash_convert_to_string_each_ctx ctx; | ||
3297 | |||
3298 | ctx.subtype = tmem->subtype; | ||
3299 | ctx.str = str; | ||
3300 | ctx.first = EINA_TRUE; | ||
3301 | eina_value_setup(&ctx.tmp, EINA_VALUE_TYPE_STRING); | ||
3302 | |||
3303 | eina_strbuf_append_char(str, '{'); | ||
3304 | |||
3305 | eina_hash_foreach(tmem->hash, | ||
3306 | _eina_value_type_hash_convert_to_string_each, | ||
3307 | &ctx); | ||
3308 | |||
3309 | eina_strbuf_append_char(str, '}'); | ||
3310 | } | ||
3311 | s = eina_strbuf_string_get(str); | ||
3312 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
3313 | eina_strbuf_free(str); | ||
3314 | } | ||
3315 | else if ((tmem->hash) && (eina_hash_population(tmem->hash) == 1)) | ||
3316 | { | ||
3317 | const Eina_Value_Type *subtype = tmem->subtype; | ||
3318 | void *imem = NULL; | ||
3319 | |||
3320 | eina_hash_foreach(tmem->hash, _eina_value_type_hash_find_first, &imem); | ||
3321 | if (!imem) /* shouldn't happen... */ | ||
3322 | ret = EINA_FALSE; | ||
3323 | else | ||
3324 | { | ||
3325 | if (subtype->convert_to) | ||
3326 | ret = subtype->convert_to(subtype, convert, imem, convert_mem); | ||
3327 | if ((!ret) && (convert->convert_from)) | ||
3328 | ret = convert->convert_from(convert, subtype, convert_mem, imem); | ||
3329 | } | ||
3330 | } | ||
3331 | |||
3332 | if (!ret) | ||
3333 | { | ||
3334 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3335 | return EINA_FALSE; | ||
3336 | } | ||
3337 | return EINA_TRUE; | ||
3338 | } | ||
3339 | |||
3340 | static Eina_Bool | ||
3341 | _eina_value_type_hash_pset(const Eina_Value_Type *type, void *mem, const void *ptr) | ||
3342 | { | ||
3343 | Eina_Value_Hash *tmem = mem; | ||
3344 | const Eina_Value_Hash *desc = ptr; | ||
3345 | |||
3346 | eina_error_set(0); | ||
3347 | if ((!tmem->subtype) && (!desc->subtype)) | ||
3348 | return EINA_TRUE; | ||
3349 | |||
3350 | if ((tmem->hash) && (tmem->hash == desc->hash)) | ||
3351 | { | ||
3352 | tmem->subtype = desc->subtype; | ||
3353 | return EINA_TRUE; | ||
3354 | } | ||
3355 | |||
3356 | if (desc->hash) | ||
3357 | { | ||
3358 | Eina_Value_Hash tmp; | ||
3359 | |||
3360 | if (!_eina_value_type_hash_copy(type, desc, &tmp)) | ||
3361 | return EINA_FALSE; | ||
3362 | |||
3363 | _eina_value_type_hash_flush(type, tmem); | ||
3364 | memcpy(tmem, &tmp, sizeof(tmp)); | ||
3365 | return EINA_TRUE; | ||
3366 | } | ||
3367 | |||
3368 | if (tmem->hash) _eina_value_type_hash_flush_elements(tmem); | ||
3369 | |||
3370 | tmem->subtype = desc->subtype; | ||
3371 | if (!_eina_value_type_hash_create(tmem)) | ||
3372 | return EINA_FALSE; | ||
3373 | |||
3374 | return EINA_TRUE; | ||
3375 | } | ||
3376 | |||
3377 | static Eina_Bool | ||
3378 | _eina_value_type_hash_vset(const Eina_Value_Type *type, void *mem, va_list args) | ||
3379 | { | ||
3380 | const Eina_Value_Hash desc = va_arg(args, Eina_Value_Hash); | ||
3381 | _eina_value_type_hash_pset(type, mem, &desc); | ||
3382 | return EINA_TRUE; | ||
3383 | } | ||
3384 | |||
3385 | static Eina_Bool | ||
3386 | _eina_value_type_hash_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
3387 | { | ||
3388 | memcpy(ptr, mem, sizeof(Eina_Value_Hash)); | ||
3389 | return EINA_TRUE; | ||
3390 | } | ||
3391 | |||
3392 | static const Eina_Value_Type _EINA_VALUE_TYPE_HASH = { | ||
3393 | EINA_VALUE_TYPE_VERSION, | ||
3394 | sizeof(Eina_Value_Hash), | ||
3395 | "Eina_Value_Hash", | ||
3396 | _eina_value_type_hash_setup, | ||
3397 | _eina_value_type_hash_flush, | ||
3398 | _eina_value_type_hash_copy, | ||
3399 | _eina_value_type_hash_compare, | ||
3400 | _eina_value_type_hash_convert_to, | ||
3401 | NULL, /* no convert from */ | ||
3402 | _eina_value_type_hash_vset, | ||
3403 | _eina_value_type_hash_pset, | ||
3404 | _eina_value_type_hash_pget | ||
3405 | }; | ||
3406 | |||
3407 | static Eina_Bool | ||
3408 | _eina_value_type_timeval_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
3409 | { | ||
3410 | memset(mem, 0, sizeof(struct timeval)); | ||
3411 | return EINA_TRUE; | ||
3412 | } | ||
3413 | |||
3414 | static Eina_Bool | ||
3415 | _eina_value_type_timeval_flush(const Eina_Value_Type *type __UNUSED__, void *mem __UNUSED__) | ||
3416 | { | ||
3417 | return EINA_TRUE; | ||
3418 | } | ||
3419 | |||
3420 | static Eina_Bool | ||
3421 | _eina_value_type_timeval_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
3422 | { | ||
3423 | const struct timeval *s = src; | ||
3424 | struct timeval *d = dst; | ||
3425 | *d = *s; | ||
3426 | return EINA_TRUE; | ||
3427 | } | ||
3428 | |||
3429 | static inline struct timeval _eina_value_type_timeval_fix(const struct timeval *input) | ||
3430 | { | ||
3431 | struct timeval ret = *input; | ||
3432 | if (EINA_UNLIKELY(ret.tv_usec < 0)) | ||
3433 | { | ||
3434 | ret.tv_sec -= 1; | ||
3435 | ret.tv_usec += 1e6; | ||
3436 | } | ||
3437 | return ret; | ||
3438 | } | ||
3439 | |||
3440 | static int | ||
3441 | _eina_value_type_timeval_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
3442 | { | ||
3443 | struct timeval va = _eina_value_type_timeval_fix(a); | ||
3444 | struct timeval vb = _eina_value_type_timeval_fix(b); | ||
3445 | |||
3446 | if (va.tv_sec < vb.tv_sec) | ||
3447 | return -1; | ||
3448 | else if (va.tv_sec > vb.tv_sec) | ||
3449 | return 1; | ||
3450 | |||
3451 | if (va.tv_usec < vb.tv_usec) | ||
3452 | return -1; | ||
3453 | else if (va.tv_usec > vb.tv_usec) | ||
3454 | return 1; | ||
3455 | |||
3456 | return 0; | ||
3457 | } | ||
3458 | |||
3459 | static Eina_Bool | ||
3460 | _eina_value_type_timeval_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
3461 | { | ||
3462 | struct timeval v = _eina_value_type_timeval_fix(type_mem); | ||
3463 | |||
3464 | eina_error_set(0); | ||
3465 | |||
3466 | if (convert == EINA_VALUE_TYPE_UCHAR) | ||
3467 | { | ||
3468 | unsigned char other_mem = v.tv_sec; | ||
3469 | if (EINA_UNLIKELY(v.tv_sec < 0)) | ||
3470 | return EINA_FALSE; | ||
3471 | if (EINA_UNLIKELY(v.tv_sec > eina_value_uchar_max)) | ||
3472 | return EINA_FALSE; | ||
3473 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3474 | } | ||
3475 | else if (convert == EINA_VALUE_TYPE_USHORT) | ||
3476 | { | ||
3477 | unsigned short other_mem = v.tv_sec; | ||
3478 | if (EINA_UNLIKELY(v.tv_sec < 0)) | ||
3479 | return EINA_FALSE; | ||
3480 | if (EINA_UNLIKELY(v.tv_sec > eina_value_ushort_max)) | ||
3481 | return EINA_FALSE; | ||
3482 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3483 | } | ||
3484 | else if (convert == EINA_VALUE_TYPE_UINT) | ||
3485 | { | ||
3486 | unsigned int other_mem = v.tv_sec; | ||
3487 | if (EINA_UNLIKELY(v.tv_sec < 0)) | ||
3488 | return EINA_FALSE; | ||
3489 | if (EINA_UNLIKELY((unsigned long) v.tv_sec > eina_value_uint_max)) | ||
3490 | return EINA_FALSE; | ||
3491 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3492 | } | ||
3493 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) | ||
3494 | { | ||
3495 | unsigned long other_mem = v.tv_sec; | ||
3496 | if (EINA_UNLIKELY(v.tv_sec < 0)) | ||
3497 | return EINA_FALSE; | ||
3498 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && | ||
3499 | ((unsigned long)v.tv_sec > eina_value_ulong_max))) | ||
3500 | return EINA_FALSE; | ||
3501 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3502 | } | ||
3503 | else if (convert == EINA_VALUE_TYPE_UINT64) | ||
3504 | { | ||
3505 | uint64_t other_mem = v.tv_sec; | ||
3506 | if (EINA_UNLIKELY(v.tv_sec < 0)) | ||
3507 | return EINA_FALSE; | ||
3508 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3509 | } | ||
3510 | else if (convert == EINA_VALUE_TYPE_CHAR) | ||
3511 | { | ||
3512 | char other_mem = v.tv_sec; | ||
3513 | if (EINA_UNLIKELY(v.tv_sec < eina_value_char_min)) | ||
3514 | return EINA_FALSE; | ||
3515 | if (EINA_UNLIKELY(v.tv_sec > eina_value_char_max)) | ||
3516 | return EINA_FALSE; | ||
3517 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3518 | } | ||
3519 | else if (convert == EINA_VALUE_TYPE_SHORT) | ||
3520 | { | ||
3521 | short other_mem = v.tv_sec; | ||
3522 | if (EINA_UNLIKELY(v.tv_sec < eina_value_short_min)) | ||
3523 | return EINA_FALSE; | ||
3524 | if (EINA_UNLIKELY(v.tv_sec > eina_value_short_max)) | ||
3525 | return EINA_FALSE; | ||
3526 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3527 | } | ||
3528 | else if (convert == EINA_VALUE_TYPE_INT) | ||
3529 | { | ||
3530 | int other_mem = v.tv_sec; | ||
3531 | if (EINA_UNLIKELY(v.tv_sec < eina_value_int_min)) | ||
3532 | return EINA_FALSE; | ||
3533 | if (EINA_UNLIKELY(v.tv_sec > eina_value_int_max)) | ||
3534 | return EINA_FALSE; | ||
3535 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3536 | } | ||
3537 | else if (convert == EINA_VALUE_TYPE_LONG) | ||
3538 | { | ||
3539 | long other_mem = v.tv_sec; | ||
3540 | if (EINA_UNLIKELY(v.tv_sec < eina_value_long_min)) | ||
3541 | return EINA_FALSE; | ||
3542 | if (EINA_UNLIKELY(v.tv_sec > eina_value_long_max)) | ||
3543 | return EINA_FALSE; | ||
3544 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3545 | } | ||
3546 | else if (convert == EINA_VALUE_TYPE_INT64) | ||
3547 | { | ||
3548 | int64_t other_mem = v.tv_sec; | ||
3549 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3550 | } | ||
3551 | else if (convert == EINA_VALUE_TYPE_FLOAT) | ||
3552 | { | ||
3553 | float other_mem = (float)v.tv_sec + (float)v.tv_usec / 1.0e6; | ||
3554 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3555 | } | ||
3556 | else if (convert == EINA_VALUE_TYPE_DOUBLE) | ||
3557 | { | ||
3558 | double other_mem = (double)v.tv_sec + (double)v.tv_usec / 1.0e6; | ||
3559 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3560 | } | ||
3561 | else if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
3562 | convert == EINA_VALUE_TYPE_STRING) | ||
3563 | { | ||
3564 | const char *other_mem; | ||
3565 | char buf[64]; | ||
3566 | snprintf(buf, sizeof(buf), "%ld.%06ld", v.tv_sec, v.tv_usec); | ||
3567 | other_mem = buf; /* required due &buf == buf */ | ||
3568 | return eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3569 | } | ||
3570 | else | ||
3571 | { | ||
3572 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3573 | return EINA_FALSE; | ||
3574 | } | ||
3575 | } | ||
3576 | |||
3577 | static Eina_Bool | ||
3578 | _eina_value_type_timeval_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
3579 | { | ||
3580 | struct timeval *tmem = mem; | ||
3581 | *tmem = _eina_value_type_timeval_fix(ptr); | ||
3582 | return EINA_TRUE; | ||
3583 | } | ||
3584 | |||
3585 | static Eina_Bool | ||
3586 | _eina_value_type_timeval_vset(const Eina_Value_Type *type, void *mem, va_list args) | ||
3587 | { | ||
3588 | const struct timeval desc = va_arg(args, struct timeval); | ||
3589 | _eina_value_type_timeval_pset(type, mem, &desc); | ||
3590 | return EINA_TRUE; | ||
3591 | } | ||
3592 | |||
3593 | static Eina_Bool | ||
3594 | _eina_value_type_timeval_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
3595 | { | ||
3596 | memcpy(ptr, mem, sizeof(struct timeval)); | ||
3597 | return EINA_TRUE; | ||
3598 | } | ||
3599 | |||
3600 | static const Eina_Value_Type _EINA_VALUE_TYPE_TIMEVAL = { | ||
3601 | EINA_VALUE_TYPE_VERSION, | ||
3602 | sizeof(struct timeval), | ||
3603 | "struct timeval", | ||
3604 | _eina_value_type_timeval_setup, | ||
3605 | _eina_value_type_timeval_flush, | ||
3606 | _eina_value_type_timeval_copy, | ||
3607 | _eina_value_type_timeval_compare, | ||
3608 | _eina_value_type_timeval_convert_to, | ||
3609 | NULL, /* no convert from */ | ||
3610 | _eina_value_type_timeval_vset, | ||
3611 | _eina_value_type_timeval_pset, | ||
3612 | _eina_value_type_timeval_pget | ||
3613 | }; | ||
3614 | |||
3615 | static Eina_Bool | ||
3616 | _eina_value_type_blob_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
3617 | { | ||
3618 | memset(mem, 0, sizeof(Eina_Value_Blob)); | ||
3619 | return EINA_TRUE; | ||
3620 | } | ||
3621 | |||
3622 | static inline const Eina_Value_Blob_Operations * | ||
3623 | _eina_value_type_blob_ops_get(const Eina_Value_Blob *blob) | ||
3624 | { | ||
3625 | if (!blob) return NULL; | ||
3626 | if (!blob->ops) return NULL; | ||
3627 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
3628 | (blob->ops->version == EINA_VALUE_BLOB_OPERATIONS_VERSION, NULL); | ||
3629 | return blob->ops; | ||
3630 | } | ||
3631 | |||
3632 | static Eina_Bool | ||
3633 | _eina_value_type_blob_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
3634 | { | ||
3635 | const Eina_Value_Blob_Operations *ops = _eina_value_type_blob_ops_get(mem); | ||
3636 | Eina_Value_Blob *tmem = mem; | ||
3637 | if ((ops) && (ops->free)) | ||
3638 | ops->free(ops, (void *)tmem->memory, tmem->size); | ||
3639 | tmem->memory = NULL; | ||
3640 | tmem->size = 0; | ||
3641 | return EINA_TRUE; | ||
3642 | } | ||
3643 | |||
3644 | static Eina_Bool | ||
3645 | _eina_value_type_blob_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
3646 | { | ||
3647 | const Eina_Value_Blob_Operations *ops = _eina_value_type_blob_ops_get(src); | ||
3648 | const Eina_Value_Blob *s = src; | ||
3649 | Eina_Value_Blob *d = dst; | ||
3650 | |||
3651 | *d = *s; | ||
3652 | |||
3653 | if ((ops) && (ops->copy)) | ||
3654 | { | ||
3655 | d->memory = ops->copy(ops, s->memory, s->size); | ||
3656 | if ((d->memory == NULL) && (s->size > 0)) | ||
3657 | return EINA_FALSE; | ||
3658 | } | ||
3659 | |||
3660 | return EINA_TRUE; | ||
3661 | } | ||
3662 | |||
3663 | static int | ||
3664 | _eina_value_type_blob_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
3665 | { | ||
3666 | const Eina_Value_Blob_Operations *ops = _eina_value_type_blob_ops_get(a); | ||
3667 | const Eina_Value_Blob *ta = a, *tb = b; | ||
3668 | size_t minsize; | ||
3669 | if (ta->ops != tb->ops) | ||
3670 | { | ||
3671 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3672 | return -1; | ||
3673 | } | ||
3674 | if ((ops) && (ops->compare)) | ||
3675 | return ops->compare(ops, ta->memory, ta->size, tb->memory, tb->size); | ||
3676 | |||
3677 | if (ta->size < tb->size) | ||
3678 | minsize = ta->size; | ||
3679 | else | ||
3680 | minsize = tb->size; | ||
3681 | |||
3682 | return memcmp(ta->memory, tb->memory, minsize); | ||
3683 | } | ||
3684 | |||
3685 | static Eina_Bool | ||
3686 | _eina_value_type_blob_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
3687 | { | ||
3688 | const Eina_Value_Blob *tmem = type_mem; | ||
3689 | |||
3690 | eina_error_set(0); | ||
3691 | if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
3692 | convert == EINA_VALUE_TYPE_STRING) | ||
3693 | { | ||
3694 | const Eina_Value_Blob_Operations *ops; | ||
3695 | Eina_Strbuf *str; | ||
3696 | const char *other_mem; | ||
3697 | Eina_Bool ret = EINA_FALSE, first = EINA_TRUE; | ||
3698 | const unsigned char *ptr, *ptr_end; | ||
3699 | |||
3700 | ops = _eina_value_type_blob_ops_get(tmem); | ||
3701 | if ((ops) && (ops->to_string)) | ||
3702 | { | ||
3703 | char *x = ops->to_string(ops, tmem->memory, tmem->size); | ||
3704 | if (x) | ||
3705 | { | ||
3706 | ret = eina_value_type_pset(convert, convert_mem, &x); | ||
3707 | free(x); | ||
3708 | } | ||
3709 | return ret; | ||
3710 | } | ||
3711 | |||
3712 | str = eina_strbuf_new(); | ||
3713 | if (!str) | ||
3714 | return EINA_FALSE; | ||
3715 | |||
3716 | if (!eina_strbuf_append_printf(str, "BLOB(%u, [", tmem->size)) | ||
3717 | goto error; | ||
3718 | |||
3719 | ptr = tmem->memory; | ||
3720 | ptr_end = ptr + tmem->size; | ||
3721 | for (; ptr < ptr_end; ptr++) | ||
3722 | { | ||
3723 | if (first) | ||
3724 | { | ||
3725 | first = EINA_FALSE; | ||
3726 | if (!eina_strbuf_append_printf(str, "%02hhx", *ptr)) | ||
3727 | goto error; | ||
3728 | } | ||
3729 | else | ||
3730 | { | ||
3731 | if (!eina_strbuf_append_printf(str, " %02hhx", *ptr)) | ||
3732 | goto error; | ||
3733 | } | ||
3734 | } | ||
3735 | |||
3736 | if (!eina_strbuf_append(str, "])")) | ||
3737 | goto error; | ||
3738 | |||
3739 | other_mem = eina_strbuf_string_get(str); | ||
3740 | ret = eina_value_type_pset(convert, convert_mem, &other_mem); | ||
3741 | |||
3742 | error: | ||
3743 | eina_strbuf_free(str); | ||
3744 | return ret; | ||
3745 | } | ||
3746 | else | ||
3747 | { | ||
3748 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
3749 | return EINA_FALSE; | ||
3750 | } | ||
3751 | } | ||
3752 | |||
3753 | static Eina_Bool | ||
3754 | _eina_value_type_blob_convert_from(const Eina_Value_Type *type, const Eina_Value_Type *convert, void *type_mem, const void *convert_mem) | ||
3755 | { | ||
3756 | Eina_Value_Blob desc; | ||
3757 | char *buf; | ||
3758 | |||
3759 | desc.ops = EINA_VALUE_BLOB_OPERATIONS_MALLOC; | ||
3760 | |||
3761 | if ((convert == EINA_VALUE_TYPE_STRING) || | ||
3762 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | ||
3763 | { | ||
3764 | const char *str = *(const char **)convert_mem; | ||
3765 | if (!str) | ||
3766 | { | ||
3767 | desc.size = 0; | ||
3768 | desc.memory = NULL; | ||
3769 | } | ||
3770 | else | ||
3771 | { | ||
3772 | desc.size = strlen(str) + 1; | ||
3773 | desc.memory = buf = malloc(desc.size); | ||
3774 | if (!desc.memory) | ||
3775 | { | ||
3776 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
3777 | return EINA_FALSE; | ||
3778 | } | ||
3779 | memcpy(buf, str, desc.size); | ||
3780 | } | ||
3781 | } | ||
3782 | else if (convert == EINA_VALUE_TYPE_ARRAY) | ||
3783 | { | ||
3784 | const Eina_Value_Array *a = convert_mem; | ||
3785 | if ((!a->array) || (a->array->len == 0)) | ||
3786 | { | ||
3787 | desc.size = 0; | ||
3788 | desc.memory = NULL; | ||
3789 | } | ||
3790 | else | ||
3791 | { | ||
3792 | desc.size = a->array->len * a->array->member_size; | ||
3793 | desc.memory = buf = malloc(desc.size); | ||
3794 | if (!desc.memory) | ||
3795 | { | ||
3796 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
3797 | return EINA_FALSE; | ||
3798 | } | ||
3799 | memcpy(buf, a->array->members, desc.size); | ||
3800 | } | ||
3801 | } | ||
3802 | else if (convert == EINA_VALUE_TYPE_BLOB) | ||
3803 | { | ||
3804 | const Eina_Value_Blob *b = convert_mem; | ||
3805 | if (b->size == 0) | ||
3806 | { | ||
3807 | desc.size = 0; | ||
3808 | desc.memory = NULL; | ||
3809 | } | ||
3810 | else | ||
3811 | { | ||
3812 | desc.size = b->size; | ||
3813 | desc.memory = buf = malloc(desc.size); | ||
3814 | if (!desc.memory) | ||
3815 | { | ||
3816 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
3817 | return EINA_FALSE; | ||
3818 | } | ||
3819 | memcpy(buf, b->memory, desc.size); | ||
3820 | } | ||
3821 | } | ||
3822 | else | ||
3823 | { | ||
3824 | desc.size = convert->value_size; | ||
3825 | desc.memory = buf = malloc(convert->value_size); | ||
3826 | if (!desc.memory) | ||
3827 | { | ||
3828 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
3829 | return EINA_FALSE; | ||
3830 | } | ||
3831 | if (!eina_value_type_pget(convert, convert_mem, buf)) | ||
3832 | { | ||
3833 | free(buf); | ||
3834 | return EINA_FALSE; | ||
3835 | } | ||
3836 | } | ||
3837 | return eina_value_type_pset(type, type_mem, &desc); | ||
3838 | } | ||
3839 | |||
3840 | static Eina_Bool | ||
3841 | _eina_value_type_blob_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
3842 | { | ||
3843 | const Eina_Value_Blob_Operations *ops = _eina_value_type_blob_ops_get(mem); | ||
3844 | Eina_Value_Blob *tmem = mem; | ||
3845 | const Eina_Value_Blob *desc = ptr; | ||
3846 | |||
3847 | eina_error_set(0); | ||
3848 | if ((tmem->memory) && (tmem->memory == desc->memory)) | ||
3849 | { | ||
3850 | tmem->ops = desc->ops; | ||
3851 | tmem->size = desc->size; | ||
3852 | return EINA_TRUE; | ||
3853 | } | ||
3854 | |||
3855 | if ((ops) && (ops->free)) | ||
3856 | ops->free(ops, (void *)tmem->memory, tmem->size); | ||
3857 | |||
3858 | *tmem = *desc; | ||
3859 | return EINA_TRUE; | ||
3860 | } | ||
3861 | |||
3862 | static Eina_Bool | ||
3863 | _eina_value_type_blob_vset(const Eina_Value_Type *type, void *mem, va_list args) | ||
3864 | { | ||
3865 | const Eina_Value_Blob desc = va_arg(args, Eina_Value_Blob); | ||
3866 | _eina_value_type_blob_pset(type, mem, &desc); | ||
3867 | return EINA_TRUE; | ||
3868 | } | ||
3869 | |||
3870 | static Eina_Bool | ||
3871 | _eina_value_type_blob_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
3872 | { | ||
3873 | memcpy(ptr, mem, sizeof(Eina_Value_Blob)); | ||
3874 | return EINA_TRUE; | ||
3875 | } | ||
3876 | |||
3877 | static const Eina_Value_Type _EINA_VALUE_TYPE_BLOB = { | ||
3878 | EINA_VALUE_TYPE_VERSION, | ||
3879 | sizeof(Eina_Value_Blob), | ||
3880 | "Eina_Value_Blob", | ||
3881 | _eina_value_type_blob_setup, | ||
3882 | _eina_value_type_blob_flush, | ||
3883 | _eina_value_type_blob_copy, | ||
3884 | _eina_value_type_blob_compare, | ||
3885 | _eina_value_type_blob_convert_to, | ||
3886 | _eina_value_type_blob_convert_from, | ||
3887 | _eina_value_type_blob_vset, | ||
3888 | _eina_value_type_blob_pset, | ||
3889 | _eina_value_type_blob_pget | ||
3890 | }; | ||
3891 | |||
3892 | static int | ||
3893 | _eina_value_struct_operations_binsearch_cmp(const void *pa, const void *pb) | ||
3894 | { | ||
3895 | const Eina_Value_Struct_Member *a = pa, *b = pb; | ||
3896 | return strcmp(a->name, b->name); | ||
3897 | } | ||
3898 | |||
3899 | static const Eina_Value_Struct_Member * | ||
3900 | _eina_value_struct_operations_binsearch_find_member(const Eina_Value_Struct_Operations *ops __UNUSED__, const Eina_Value_Struct_Desc *desc, const char *name) | ||
3901 | { | ||
3902 | unsigned int count = desc->member_count; | ||
3903 | Eina_Value_Struct_Member search; | ||
3904 | if (count == 0) | ||
3905 | { | ||
3906 | const Eina_Value_Struct_Member *itr = desc->members; | ||
3907 | for (; itr->name != NULL; itr++) | ||
3908 | count++; | ||
3909 | } | ||
3910 | |||
3911 | search.name = name; | ||
3912 | return bsearch(&search, desc->members, count, | ||
3913 | sizeof(Eina_Value_Struct_Member), | ||
3914 | _eina_value_struct_operations_binsearch_cmp); | ||
3915 | } | ||
3916 | |||
3917 | static Eina_Value_Struct_Operations _EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH = { | ||
3918 | EINA_VALUE_STRUCT_OPERATIONS_VERSION, | ||
3919 | NULL, /* default alloc */ | ||
3920 | NULL, /* default free */ | ||
3921 | NULL, /* default copy */ | ||
3922 | NULL, /* default compare */ | ||
3923 | _eina_value_struct_operations_binsearch_find_member | ||
3924 | }; | ||
3925 | |||
3926 | static const Eina_Value_Struct_Member * | ||
3927 | _eina_value_struct_operations_stringshare_find_member(const Eina_Value_Struct_Operations *ops __UNUSED__, const Eina_Value_Struct_Desc *desc, const char *name) | ||
3928 | { | ||
3929 | const Eina_Value_Struct_Member *itr = desc->members; | ||
3930 | |||
3931 | /* assumes name is stringshared. | ||
3932 | * | ||
3933 | * we do this because it's the recommended usage pattern, moreover | ||
3934 | * we expect to find the member, as users shouldn't look for | ||
3935 | * non-existent members! | ||
3936 | */ | ||
3937 | if (desc->member_count > 0) | ||
3938 | { | ||
3939 | const Eina_Value_Struct_Member *itr_end = itr + desc->member_count; | ||
3940 | for (; itr < itr_end; itr++) | ||
3941 | if (itr->name == name) | ||
3942 | return itr; | ||
3943 | } | ||
3944 | else | ||
3945 | { | ||
3946 | for (; itr->name != NULL; itr++) | ||
3947 | if (itr->name == name) | ||
3948 | return itr; | ||
3949 | } | ||
3950 | |||
3951 | itr = desc->members; | ||
3952 | name = eina_stringshare_add(name); | ||
3953 | eina_stringshare_del(name); /* we'll not use the contents, this is fine */ | ||
3954 | /* stringshare and look again */ | ||
3955 | if (desc->member_count > 0) | ||
3956 | { | ||
3957 | const Eina_Value_Struct_Member *itr_end = itr + desc->member_count; | ||
3958 | for (; itr < itr_end; itr++) | ||
3959 | if (itr->name == name) | ||
3960 | return itr; | ||
3961 | } | ||
3962 | else | ||
3963 | { | ||
3964 | for (; itr->name != NULL; itr++) | ||
3965 | if (itr->name == name) | ||
3966 | return itr; | ||
3967 | } | ||
3968 | |||
3969 | return NULL; | ||
3970 | } | ||
3971 | |||
3972 | static Eina_Value_Struct_Operations _EINA_VALUE_STRUCT_OPERATIONS_STRINGSHARE = { | ||
3973 | EINA_VALUE_STRUCT_OPERATIONS_VERSION, | ||
3974 | NULL, /* default alloc */ | ||
3975 | NULL, /* default free */ | ||
3976 | NULL, /* default copy */ | ||
3977 | NULL, /* default compare */ | ||
3978 | _eina_value_struct_operations_stringshare_find_member | ||
3979 | }; | ||
3980 | |||
3981 | static inline const Eina_Value_Struct_Operations * | ||
3982 | _eina_value_type_struct_ops_get(const Eina_Value_Struct *st) | ||
3983 | { | ||
3984 | if (!st) return NULL; | ||
3985 | if (!st->desc) return NULL; | ||
3986 | if (!st->desc->ops) return NULL; | ||
3987 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
3988 | (st->desc->ops->version == EINA_VALUE_STRUCT_OPERATIONS_VERSION, NULL); | ||
3989 | return st->desc->ops; | ||
3990 | } | ||
3991 | |||
3992 | EAPI const Eina_Value_Struct_Member * | ||
3993 | eina_value_struct_member_find(const Eina_Value_Struct *st, const char *name) | ||
3994 | { | ||
3995 | const Eina_Value_Struct_Operations *ops; | ||
3996 | const Eina_Value_Struct_Member *itr; | ||
3997 | |||
3998 | EINA_SAFETY_ON_NULL_RETURN_VAL(st, NULL); | ||
3999 | EINA_SAFETY_ON_NULL_RETURN_VAL(st->desc, NULL); | ||
4000 | |||
4001 | ops = _eina_value_type_struct_ops_get(st); | ||
4002 | if ((ops) && (ops->find_member)) | ||
4003 | return ops->find_member(ops, st->desc, name); | ||
4004 | |||
4005 | itr = st->desc->members; | ||
4006 | if (st->desc->member_count) | ||
4007 | { | ||
4008 | const Eina_Value_Struct_Member *itr_end = itr + st->desc->member_count; | ||
4009 | for (; itr < itr_end; itr++) | ||
4010 | { | ||
4011 | if (strcmp(name, itr->name) == 0) | ||
4012 | return itr; | ||
4013 | } | ||
4014 | return NULL; | ||
4015 | } | ||
4016 | else | ||
4017 | { | ||
4018 | for (; itr->name != NULL; itr++) | ||
4019 | { | ||
4020 | if (strcmp(name, itr->name) == 0) | ||
4021 | return itr; | ||
4022 | } | ||
4023 | return NULL; | ||
4024 | } | ||
4025 | } | ||
4026 | |||
4027 | static Eina_Bool | ||
4028 | _eina_value_type_struct_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
4029 | { | ||
4030 | memset(mem, 0, sizeof(Eina_Value_Struct)); | ||
4031 | return EINA_TRUE; | ||
4032 | } | ||
4033 | |||
4034 | static Eina_Bool | ||
4035 | _eina_value_type_struct_setup_member(const Eina_Value_Struct_Member *member, Eina_Value_Struct *st) | ||
4036 | { | ||
4037 | unsigned char *base = st->memory; | ||
4038 | return eina_value_type_setup(member->type, base + member->offset); | ||
4039 | } | ||
4040 | |||
4041 | static Eina_Bool | ||
4042 | _eina_value_type_struct_flush_member(const Eina_Value_Struct_Member *member, Eina_Value_Struct *st) | ||
4043 | { | ||
4044 | unsigned char *base = st->memory; | ||
4045 | return eina_value_type_flush(member->type, base + member->offset); | ||
4046 | } | ||
4047 | |||
4048 | static Eina_Bool | ||
4049 | _eina_value_type_struct_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
4050 | { | ||
4051 | const Eina_Value_Struct_Operations *ops; | ||
4052 | const Eina_Value_Struct_Member *itr; | ||
4053 | Eina_Value_Struct *tmem = mem; | ||
4054 | Eina_Bool ret = EINA_TRUE; | ||
4055 | |||
4056 | if ((!tmem->desc) || (!tmem->memory)) | ||
4057 | return EINA_TRUE; | ||
4058 | |||
4059 | itr = tmem->desc->members; | ||
4060 | if (tmem->desc->member_count > 0) | ||
4061 | { | ||
4062 | const Eina_Value_Struct_Member *itr_end; | ||
4063 | itr_end = itr + tmem->desc->member_count; | ||
4064 | for (; itr < itr_end; itr++) | ||
4065 | ret &= _eina_value_type_struct_flush_member(itr, tmem); | ||
4066 | } | ||
4067 | else | ||
4068 | { | ||
4069 | for (; itr->name != NULL; itr++) | ||
4070 | ret &= _eina_value_type_struct_flush_member(itr, tmem); | ||
4071 | } | ||
4072 | |||
4073 | ops = _eina_value_type_struct_ops_get(mem); | ||
4074 | if ((ops) && (ops->free)) | ||
4075 | ops->free(ops, tmem->desc, tmem->memory); | ||
4076 | else | ||
4077 | free(tmem->memory); | ||
4078 | |||
4079 | tmem->memory = NULL; | ||
4080 | tmem->desc = NULL; | ||
4081 | |||
4082 | return ret; | ||
4083 | } | ||
4084 | |||
4085 | static Eina_Bool | ||
4086 | _eina_value_type_struct_copy_member(const Eina_Value_Struct_Member *member, const Eina_Value_Struct *s, Eina_Value_Struct *d) | ||
4087 | { | ||
4088 | const unsigned char *base_s = s->memory; | ||
4089 | unsigned char *base_d = d->memory; | ||
4090 | return eina_value_type_copy(member->type, | ||
4091 | base_s + member->offset, | ||
4092 | base_d + member->offset); | ||
4093 | } | ||
4094 | |||
4095 | static Eina_Bool | ||
4096 | _eina_value_type_struct_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
4097 | { | ||
4098 | const Eina_Value_Struct_Operations *ops; | ||
4099 | const Eina_Value_Struct_Member *itr; | ||
4100 | const Eina_Value_Struct *s = src; | ||
4101 | Eina_Value_Struct *d = dst; | ||
4102 | |||
4103 | *d = *s; | ||
4104 | |||
4105 | if ((!s->desc) || (!s->memory)) | ||
4106 | return EINA_TRUE; | ||
4107 | |||
4108 | ops = _eina_value_type_struct_ops_get(src); | ||
4109 | if ((ops) && (ops->copy)) | ||
4110 | { | ||
4111 | d->memory = ops->copy(ops, s->desc, s->memory); | ||
4112 | if (d->memory == NULL) | ||
4113 | return EINA_FALSE; | ||
4114 | return EINA_TRUE; | ||
4115 | } | ||
4116 | |||
4117 | if ((ops) && (ops->alloc)) | ||
4118 | d->memory = ops->alloc(ops, s->desc); | ||
4119 | else | ||
4120 | d->memory = malloc(s->desc->size); | ||
4121 | if (!d->memory) | ||
4122 | { | ||
4123 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
4124 | return EINA_FALSE; | ||
4125 | } | ||
4126 | |||
4127 | itr = s->desc->members; | ||
4128 | if (s->desc->member_count > 0) | ||
4129 | { | ||
4130 | const Eina_Value_Struct_Member *itr_end = itr + s->desc->member_count; | ||
4131 | for (; itr < itr_end; itr++) | ||
4132 | if (!_eina_value_type_struct_copy_member(itr, s, d)) | ||
4133 | goto error; | ||
4134 | } | ||
4135 | else | ||
4136 | { | ||
4137 | for (; itr->name != NULL; itr++) | ||
4138 | if (!_eina_value_type_struct_copy_member(itr, s, d)) | ||
4139 | goto error; | ||
4140 | } | ||
4141 | |||
4142 | return EINA_TRUE; | ||
4143 | |||
4144 | error: | ||
4145 | itr--; | ||
4146 | for (; itr >= s->desc->members; itr--) | ||
4147 | _eina_value_type_struct_flush_member(itr, d); | ||
4148 | |||
4149 | if ((ops) && (ops->free)) | ||
4150 | ops->free(ops, s->desc, d->memory); | ||
4151 | else | ||
4152 | free(d->memory); | ||
4153 | return EINA_FALSE; | ||
4154 | } | ||
4155 | |||
4156 | static inline int | ||
4157 | _eina_value_type_struct_compare_member(const Eina_Value_Struct_Member *member, const Eina_Value_Struct *ta, const Eina_Value_Struct *tb) | ||
4158 | { | ||
4159 | const unsigned char *base_a = ta->memory; | ||
4160 | const unsigned char *base_b = tb->memory; | ||
4161 | return eina_value_type_compare(member->type, | ||
4162 | base_a + member->offset, | ||
4163 | base_b + member->offset); | ||
4164 | } | ||
4165 | |||
4166 | static int | ||
4167 | _eina_value_type_struct_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
4168 | { | ||
4169 | const Eina_Value_Struct_Operations *ops = _eina_value_type_struct_ops_get(a); | ||
4170 | const Eina_Value_Struct *ta = a, *tb = b; | ||
4171 | const Eina_Value_Struct_Member *itr; | ||
4172 | int cmp = 0; | ||
4173 | |||
4174 | if ((!ta->desc) && (!tb->desc)) | ||
4175 | return 0; | ||
4176 | else if (ta->desc != tb->desc) | ||
4177 | { | ||
4178 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
4179 | return -1; | ||
4180 | } | ||
4181 | if (ta->desc->ops != tb->desc->ops) | ||
4182 | { | ||
4183 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
4184 | return -1; | ||
4185 | } | ||
4186 | if ((!ta->memory) && (!tb->memory)) | ||
4187 | return 0; | ||
4188 | else if (!ta->memory) | ||
4189 | return -1; | ||
4190 | else if (!tb->memory) | ||
4191 | return 1; | ||
4192 | |||
4193 | if ((ops) && (ops->compare)) | ||
4194 | return ops->compare(ops, ta->desc, ta->memory, tb->memory); | ||
4195 | |||
4196 | itr = ta->desc->members; | ||
4197 | if (ta->desc->member_count > 0) | ||
4198 | { | ||
4199 | const Eina_Value_Struct_Member *itr_end = itr + ta->desc->member_count; | ||
4200 | for (; (cmp == 0) && (itr < itr_end); itr++) | ||
4201 | cmp = _eina_value_type_struct_compare_member(itr, ta, tb); | ||
4202 | } | ||
4203 | else | ||
4204 | { | ||
4205 | for (; (cmp == 0) && (itr->name != NULL); itr++) | ||
4206 | cmp = _eina_value_type_struct_compare_member(itr, ta, tb); | ||
4207 | } | ||
4208 | return cmp; | ||
4209 | } | ||
4210 | |||
4211 | static void | ||
4212 | _eina_value_type_struct_convert_to_string_member(const Eina_Value_Struct *st, const Eina_Value_Struct_Member *member, Eina_Strbuf *str) | ||
4213 | { | ||
4214 | const unsigned char *p = st->memory; | ||
4215 | Eina_Bool first = st->desc->members == member; | ||
4216 | Eina_Bool r = EINA_FALSE; | ||
4217 | |||
4218 | if (first) eina_strbuf_append_printf(str, "%s: ", member->name); | ||
4219 | else eina_strbuf_append_printf(str, ", %s: ", member->name); | ||
4220 | |||
4221 | if ((member->type) && (member->type->convert_to)) | ||
4222 | { | ||
4223 | const Eina_Value_Type *type = member->type; | ||
4224 | char *conv = NULL; | ||
4225 | |||
4226 | r = eina_value_type_convert_to(type, EINA_VALUE_TYPE_STRING, | ||
4227 | p + member->offset, &conv); | ||
4228 | if (r) | ||
4229 | { | ||
4230 | eina_strbuf_append(str, conv); | ||
4231 | free(conv); | ||
4232 | } | ||
4233 | } | ||
4234 | |||
4235 | if (!r) | ||
4236 | eina_strbuf_append_char(str, '?'); | ||
4237 | } | ||
4238 | |||
4239 | static Eina_Bool | ||
4240 | _eina_value_type_struct_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
4241 | { | ||
4242 | const Eina_Value_Struct *tmem = type_mem; | ||
4243 | |||
4244 | eina_error_set(0); | ||
4245 | if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
4246 | convert == EINA_VALUE_TYPE_STRING) | ||
4247 | { | ||
4248 | Eina_Strbuf *str = eina_strbuf_new(); | ||
4249 | const char *s; | ||
4250 | Eina_Bool ret; | ||
4251 | |||
4252 | if (!tmem->memory) eina_strbuf_append(str, "{}"); | ||
4253 | else | ||
4254 | { | ||
4255 | const Eina_Value_Struct_Member *itr = tmem->desc->members; | ||
4256 | |||
4257 | eina_strbuf_append_char(str, '{'); | ||
4258 | |||
4259 | if (tmem->desc->member_count > 0) | ||
4260 | { | ||
4261 | const Eina_Value_Struct_Member *itr_end; | ||
4262 | |||
4263 | itr_end = itr + tmem->desc->member_count; | ||
4264 | for (; itr < itr_end; itr++) | ||
4265 | _eina_value_type_struct_convert_to_string_member | ||
4266 | (tmem, itr, str); | ||
4267 | } | ||
4268 | else | ||
4269 | { | ||
4270 | for (; itr->name != NULL; itr++) | ||
4271 | _eina_value_type_struct_convert_to_string_member | ||
4272 | (tmem, itr, str); | ||
4273 | } | ||
4274 | |||
4275 | eina_strbuf_append_char(str, '}'); | ||
4276 | } | ||
4277 | s = eina_strbuf_string_get(str); | ||
4278 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
4279 | eina_strbuf_free(str); | ||
4280 | return ret; | ||
4281 | } | ||
4282 | else | ||
4283 | { | ||
4284 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
4285 | return EINA_FALSE; | ||
4286 | } | ||
4287 | } | ||
4288 | |||
4289 | static Eina_Bool | ||
4290 | _eina_value_type_struct_desc_check(const Eina_Value_Struct_Desc *desc) | ||
4291 | { | ||
4292 | unsigned int minsize = 0; | ||
4293 | const Eina_Value_Struct_Member *itr; | ||
4294 | |||
4295 | EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE); | ||
4296 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
4297 | (desc->version == EINA_VALUE_STRUCT_DESC_VERSION, EINA_FALSE); | ||
4298 | |||
4299 | itr = desc->members; | ||
4300 | if (desc->member_count > 0) | ||
4301 | { | ||
4302 | const Eina_Value_Struct_Member *itr_end = itr + desc->member_count; | ||
4303 | for (; itr < itr_end; itr++) | ||
4304 | { | ||
4305 | unsigned int member_end; | ||
4306 | |||
4307 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
4308 | (eina_value_type_check(itr->type), EINA_FALSE); | ||
4309 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
4310 | (itr->type->value_size > 0, EINA_FALSE); | ||
4311 | |||
4312 | member_end = itr->offset + itr->type->value_size; | ||
4313 | if (minsize < member_end) | ||
4314 | minsize = member_end; | ||
4315 | } | ||
4316 | } | ||
4317 | else | ||
4318 | { | ||
4319 | for (; itr->name != NULL; itr++) | ||
4320 | { | ||
4321 | unsigned int member_end; | ||
4322 | |||
4323 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
4324 | (eina_value_type_check(itr->type), EINA_FALSE); | ||
4325 | EINA_SAFETY_ON_FALSE_RETURN_VAL | ||
4326 | (itr->type->value_size > 0, EINA_FALSE); | ||
4327 | |||
4328 | member_end = itr->offset + itr->type->value_size; | ||
4329 | if (minsize < member_end) | ||
4330 | minsize = member_end; | ||
4331 | } | ||
4332 | } | ||
4333 | |||
4334 | EINA_SAFETY_ON_FALSE_RETURN_VAL(minsize > 0, EINA_FALSE); | ||
4335 | EINA_SAFETY_ON_FALSE_RETURN_VAL(desc->size >= minsize, EINA_FALSE); | ||
4336 | return EINA_TRUE; | ||
4337 | } | ||
4338 | |||
4339 | static Eina_Bool | ||
4340 | _eina_value_type_struct_pset(const Eina_Value_Type *type, void *mem, const void *ptr) | ||
4341 | { | ||
4342 | const Eina_Value_Struct_Operations *ops; | ||
4343 | Eina_Value_Struct *tmem = mem; | ||
4344 | const Eina_Value_Struct *desc = ptr; | ||
4345 | const Eina_Value_Struct_Member *itr; | ||
4346 | |||
4347 | if (!_eina_value_type_struct_desc_check(desc->desc)) | ||
4348 | { | ||
4349 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
4350 | return EINA_FALSE; | ||
4351 | } | ||
4352 | |||
4353 | eina_error_set(0); | ||
4354 | if ((tmem->memory) && (tmem->memory == desc->memory)) | ||
4355 | { | ||
4356 | tmem->desc = desc->desc; | ||
4357 | return EINA_TRUE; | ||
4358 | } | ||
4359 | |||
4360 | if (desc->memory) | ||
4361 | { | ||
4362 | Eina_Value_Struct tmp; | ||
4363 | |||
4364 | if (!_eina_value_type_struct_copy(type, desc, &tmp)) | ||
4365 | return EINA_FALSE; | ||
4366 | |||
4367 | _eina_value_type_struct_flush(type, tmem); | ||
4368 | memcpy(tmem, &tmp, sizeof(tmp)); | ||
4369 | return EINA_TRUE; | ||
4370 | } | ||
4371 | |||
4372 | if (tmem->memory) _eina_value_type_struct_flush(type, mem); | ||
4373 | |||
4374 | tmem->desc = desc->desc; | ||
4375 | |||
4376 | ops = _eina_value_type_struct_ops_get(desc); | ||
4377 | if ((ops) && (ops->alloc)) | ||
4378 | tmem->memory = ops->alloc(ops, tmem->desc); | ||
4379 | else | ||
4380 | tmem->memory = malloc(tmem->desc->size); | ||
4381 | |||
4382 | if (!tmem->memory) | ||
4383 | { | ||
4384 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
4385 | return EINA_FALSE; | ||
4386 | } | ||
4387 | |||
4388 | itr = tmem->desc->members; | ||
4389 | if (tmem->desc->member_count > 0) | ||
4390 | { | ||
4391 | const Eina_Value_Struct_Member *itr_end; | ||
4392 | itr_end = itr + tmem->desc->member_count; | ||
4393 | for (; itr < itr_end; itr++) | ||
4394 | if (!_eina_value_type_struct_setup_member(itr, tmem)) | ||
4395 | goto error; | ||
4396 | } | ||
4397 | else | ||
4398 | { | ||
4399 | for (; itr->name != NULL; itr++) | ||
4400 | if (!_eina_value_type_struct_setup_member(itr, tmem)) | ||
4401 | goto error; | ||
4402 | } | ||
4403 | |||
4404 | return EINA_TRUE; | ||
4405 | |||
4406 | error: | ||
4407 | itr--; | ||
4408 | for (; itr >= tmem->desc->members; itr--) | ||
4409 | _eina_value_type_struct_flush_member(itr, tmem); | ||
4410 | |||
4411 | if ((ops) && (ops->free)) | ||
4412 | ops->free(ops, tmem->desc, tmem->memory); | ||
4413 | else | ||
4414 | free(tmem->memory); | ||
4415 | tmem->memory = NULL; | ||
4416 | tmem->desc = NULL; | ||
4417 | return EINA_FALSE; | ||
4418 | } | ||
4419 | |||
4420 | static Eina_Bool | ||
4421 | _eina_value_type_struct_vset(const Eina_Value_Type *type, void *mem, va_list args) | ||
4422 | { | ||
4423 | const Eina_Value_Struct desc = va_arg(args, Eina_Value_Struct); | ||
4424 | _eina_value_type_struct_pset(type, mem, &desc); | ||
4425 | return EINA_TRUE; | ||
4426 | } | ||
4427 | |||
4428 | static Eina_Bool | ||
4429 | _eina_value_type_struct_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
4430 | { | ||
4431 | memcpy(ptr, mem, sizeof(Eina_Value_Struct)); | ||
4432 | return EINA_TRUE; | ||
4433 | } | ||
4434 | |||
4435 | static const Eina_Value_Type _EINA_VALUE_TYPE_STRUCT = { | ||
4436 | EINA_VALUE_TYPE_VERSION, | ||
4437 | sizeof(Eina_Value_Struct), | ||
4438 | "Eina_Value_Struct", | ||
4439 | _eina_value_type_struct_setup, | ||
4440 | _eina_value_type_struct_flush, | ||
4441 | _eina_value_type_struct_copy, | ||
4442 | _eina_value_type_struct_compare, | ||
4443 | _eina_value_type_struct_convert_to, | ||
4444 | NULL, /* no convert from */ | ||
4445 | _eina_value_type_struct_vset, | ||
4446 | _eina_value_type_struct_pset, | ||
4447 | _eina_value_type_struct_pget | ||
4448 | }; | ||
4449 | |||
4450 | static Eina_Bool | ||
4451 | _eina_value_type_model_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
4452 | { | ||
4453 | Eina_Model **tmem = mem; | ||
4454 | *tmem = NULL; | ||
4455 | return EINA_TRUE; | ||
4456 | } | ||
4457 | |||
4458 | static Eina_Bool | ||
4459 | _eina_value_type_model_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | ||
4460 | { | ||
4461 | Eina_Model **tmem = mem; | ||
4462 | if (*tmem) | ||
4463 | { | ||
4464 | eina_model_unref(*tmem); | ||
4465 | *tmem = NULL; | ||
4466 | } | ||
4467 | return EINA_TRUE; | ||
4468 | } | ||
4469 | |||
4470 | static Eina_Bool | ||
4471 | _eina_value_type_model_copy(const Eina_Value_Type *type __UNUSED__, const void *src, void *dst) | ||
4472 | { | ||
4473 | const Eina_Model * const *s = src; | ||
4474 | Eina_Model **d = dst; | ||
4475 | if (*s) | ||
4476 | *d = eina_model_copy(*s); /* is it better to deep-copy? */ | ||
4477 | else | ||
4478 | *d = NULL; | ||
4479 | return EINA_TRUE; | ||
4480 | } | ||
4481 | |||
4482 | static int | ||
4483 | _eina_value_type_model_compare(const Eina_Value_Type *type __UNUSED__, const void *a, const void *b) | ||
4484 | { | ||
4485 | const Eina_Model * const *ta = a; | ||
4486 | const Eina_Model * const *tb = b; | ||
4487 | |||
4488 | if ((!*ta) && (!*tb)) return 0; | ||
4489 | else if (!*ta) return 1; | ||
4490 | else if (!*tb) return -1; | ||
4491 | else return eina_model_compare(*ta, *tb); | ||
4492 | } | ||
4493 | |||
4494 | static Eina_Bool | ||
4495 | _eina_value_type_model_convert_to(const Eina_Value_Type *type __UNUSED__, const Eina_Value_Type *convert, const void *type_mem, void *convert_mem) | ||
4496 | { | ||
4497 | const Eina_Model *v = *(const Eina_Model **)type_mem; | ||
4498 | |||
4499 | eina_error_set(0); | ||
4500 | |||
4501 | if (convert == EINA_VALUE_TYPE_STRINGSHARE || | ||
4502 | convert == EINA_VALUE_TYPE_STRING) | ||
4503 | { | ||
4504 | char *other_mem = v ? eina_model_to_string(v) : NULL; | ||
4505 | Eina_Bool ret = eina_value_type_pset(convert, convert_mem, &other_mem); | ||
4506 | free(other_mem); | ||
4507 | return ret; | ||
4508 | } | ||
4509 | else | ||
4510 | { | ||
4511 | eina_error_set(EINA_ERROR_VALUE_FAILED); | ||
4512 | return EINA_FALSE; | ||
4513 | } | ||
4514 | |||
4515 | return EINA_TRUE; | ||
4516 | } | ||
4517 | |||
4518 | static Eina_Bool | ||
4519 | _eina_value_type_model_vset(const Eina_Value_Type *type __UNUSED__, void *mem, va_list args) | ||
4520 | { | ||
4521 | Eina_Model **tmem = mem, *tmp; | ||
4522 | |||
4523 | tmp = va_arg(args, Eina_Model *); | ||
4524 | |||
4525 | if (tmp) eina_model_ref(tmp); | ||
4526 | if (*tmem) eina_model_unref(*tmem); | ||
4527 | |||
4528 | *tmem = tmp; | ||
4529 | |||
4530 | return EINA_TRUE; | ||
4531 | } | ||
4532 | |||
4533 | static Eina_Bool | ||
4534 | _eina_value_type_model_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | ||
4535 | { | ||
4536 | Eina_Model **tmem = mem; | ||
4537 | Eina_Model **p = (Eina_Model **)ptr; | ||
4538 | |||
4539 | eina_error_set(0); | ||
4540 | if (*tmem == *p) return EINA_TRUE; | ||
4541 | |||
4542 | if (*p) eina_model_ref(*p); | ||
4543 | if (*tmem) eina_model_unref(*tmem); | ||
4544 | |||
4545 | *tmem = *p; | ||
4546 | |||
4547 | return EINA_TRUE; | ||
4548 | } | ||
4549 | |||
4550 | static Eina_Bool | ||
4551 | _eina_value_type_model_pget(const Eina_Value_Type *type __UNUSED__, const void *mem, void *ptr) | ||
4552 | { | ||
4553 | Eina_Model **tmem = (Eina_Model **)mem; | ||
4554 | Eina_Model **p = ptr; | ||
4555 | *p = *tmem; | ||
4556 | return EINA_TRUE; | ||
4557 | } | ||
4558 | |||
4559 | static const Eina_Value_Type _EINA_VALUE_TYPE_MODEL = { | ||
4560 | EINA_VALUE_TYPE_VERSION, | ||
4561 | sizeof(Eina_Model *), | ||
4562 | "Eina_Model", | ||
4563 | _eina_value_type_model_setup, | ||
4564 | _eina_value_type_model_flush, | ||
4565 | _eina_value_type_model_copy, | ||
4566 | _eina_value_type_model_compare, | ||
4567 | _eina_value_type_model_convert_to, | ||
4568 | NULL, /* no convert from */ | ||
4569 | _eina_value_type_model_vset, | ||
4570 | _eina_value_type_model_pset, | ||
4571 | _eina_value_type_model_pget | ||
4572 | }; | ||
4573 | |||
4574 | /* keep all basic types inlined in an array so we can compare if it's | ||
4575 | * a basic type using pointer arithmetic. | ||
4576 | * | ||
4577 | * NOTE-1: JUST BASIC TYPES, DO NOT ADD MORE TYPES HERE!!! | ||
4578 | * NOTE-2: KEEP ORDER, see eina_value_init() | ||
4579 | */ | ||
4580 | static const Eina_Value_Type _EINA_VALUE_TYPE_BASICS[] = { | ||
4581 | { | ||
4582 | EINA_VALUE_TYPE_VERSION, | ||
4583 | sizeof(unsigned char), | ||
4584 | "unsigned char", | ||
4585 | _eina_value_type_uchar_setup, | ||
4586 | _eina_value_type_uchar_flush, | ||
4587 | _eina_value_type_uchar_copy, | ||
4588 | _eina_value_type_uchar_compare, | ||
4589 | _eina_value_type_uchar_convert_to, | ||
4590 | NULL, /* no convert from */ | ||
4591 | _eina_value_type_uchar_vset, | ||
4592 | _eina_value_type_uchar_pset, | ||
4593 | _eina_value_type_uchar_pget | ||
4594 | }, | ||
4595 | { | ||
4596 | EINA_VALUE_TYPE_VERSION, | ||
4597 | sizeof(unsigned short), | ||
4598 | "unsigned short", | ||
4599 | _eina_value_type_ushort_setup, | ||
4600 | _eina_value_type_ushort_flush, | ||
4601 | _eina_value_type_ushort_copy, | ||
4602 | _eina_value_type_ushort_compare, | ||
4603 | _eina_value_type_ushort_convert_to, | ||
4604 | NULL, /* no convert from */ | ||
4605 | _eina_value_type_ushort_vset, | ||
4606 | _eina_value_type_ushort_pset, | ||
4607 | _eina_value_type_ushort_pget | ||
4608 | }, | ||
4609 | { | ||
4610 | EINA_VALUE_TYPE_VERSION, | ||
4611 | sizeof(unsigned int), | ||
4612 | "unsigned int", | ||
4613 | _eina_value_type_uint_setup, | ||
4614 | _eina_value_type_uint_flush, | ||
4615 | _eina_value_type_uint_copy, | ||
4616 | _eina_value_type_uint_compare, | ||
4617 | _eina_value_type_uint_convert_to, | ||
4618 | NULL, /* no convert from */ | ||
4619 | _eina_value_type_uint_vset, | ||
4620 | _eina_value_type_uint_pset, | ||
4621 | _eina_value_type_uint_pget | ||
4622 | }, | ||
4623 | { | ||
4624 | EINA_VALUE_TYPE_VERSION, | ||
4625 | sizeof(unsigned long), | ||
4626 | "unsigned long", | ||
4627 | _eina_value_type_ulong_setup, | ||
4628 | _eina_value_type_ulong_flush, | ||
4629 | _eina_value_type_ulong_copy, | ||
4630 | _eina_value_type_ulong_compare, | ||
4631 | _eina_value_type_ulong_convert_to, | ||
4632 | NULL, /* no convert from */ | ||
4633 | _eina_value_type_ulong_vset, | ||
4634 | _eina_value_type_ulong_pset, | ||
4635 | _eina_value_type_ulong_pget | ||
4636 | }, | ||
4637 | { | ||
4638 | EINA_VALUE_TYPE_VERSION, | ||
4639 | sizeof(uint64_t), | ||
4640 | "uint64_t", | ||
4641 | _eina_value_type_uint64_setup, | ||
4642 | _eina_value_type_uint64_flush, | ||
4643 | _eina_value_type_uint64_copy, | ||
4644 | _eina_value_type_uint64_compare, | ||
4645 | _eina_value_type_uint64_convert_to, | ||
4646 | NULL, /* no convert from */ | ||
4647 | _eina_value_type_uint64_vset, | ||
4648 | _eina_value_type_uint64_pset, | ||
4649 | _eina_value_type_uint64_pget | ||
4650 | }, | ||
4651 | { | ||
4652 | EINA_VALUE_TYPE_VERSION, | ||
4653 | sizeof(char), | ||
4654 | "char", | ||
4655 | _eina_value_type_char_setup, | ||
4656 | _eina_value_type_char_flush, | ||
4657 | _eina_value_type_char_copy, | ||
4658 | _eina_value_type_char_compare, | ||
4659 | _eina_value_type_char_convert_to, | ||
4660 | NULL, /* no convert from */ | ||
4661 | _eina_value_type_char_vset, | ||
4662 | _eina_value_type_char_pset, | ||
4663 | _eina_value_type_char_pget | ||
4664 | }, | ||
4665 | { | ||
4666 | EINA_VALUE_TYPE_VERSION, | ||
4667 | sizeof(short), | ||
4668 | "short", | ||
4669 | _eina_value_type_short_setup, | ||
4670 | _eina_value_type_short_flush, | ||
4671 | _eina_value_type_short_copy, | ||
4672 | _eina_value_type_short_compare, | ||
4673 | _eina_value_type_short_convert_to, | ||
4674 | NULL, /* no convert from */ | ||
4675 | _eina_value_type_short_vset, | ||
4676 | _eina_value_type_short_pset, | ||
4677 | _eina_value_type_short_pget | ||
4678 | }, | ||
4679 | { | ||
4680 | EINA_VALUE_TYPE_VERSION, | ||
4681 | sizeof(int), | ||
4682 | "int", | ||
4683 | _eina_value_type_int_setup, | ||
4684 | _eina_value_type_int_flush, | ||
4685 | _eina_value_type_int_copy, | ||
4686 | _eina_value_type_int_compare, | ||
4687 | _eina_value_type_int_convert_to, | ||
4688 | NULL, /* no convert from */ | ||
4689 | _eina_value_type_int_vset, | ||
4690 | _eina_value_type_int_pset, | ||
4691 | _eina_value_type_int_pget | ||
4692 | }, | ||
4693 | { | ||
4694 | EINA_VALUE_TYPE_VERSION, | ||
4695 | sizeof(long), | ||
4696 | "long", | ||
4697 | _eina_value_type_long_setup, | ||
4698 | _eina_value_type_long_flush, | ||
4699 | _eina_value_type_long_copy, | ||
4700 | _eina_value_type_long_compare, | ||
4701 | _eina_value_type_long_convert_to, | ||
4702 | NULL, /* no convert from */ | ||
4703 | _eina_value_type_long_vset, | ||
4704 | _eina_value_type_long_pset, | ||
4705 | _eina_value_type_long_pget | ||
4706 | }, | ||
4707 | { | ||
4708 | EINA_VALUE_TYPE_VERSION, | ||
4709 | sizeof(int64_t), | ||
4710 | "int64_t", | ||
4711 | _eina_value_type_int64_setup, | ||
4712 | _eina_value_type_int64_flush, | ||
4713 | _eina_value_type_int64_copy, | ||
4714 | _eina_value_type_int64_compare, | ||
4715 | _eina_value_type_int64_convert_to, | ||
4716 | NULL, /* no convert from */ | ||
4717 | _eina_value_type_int64_vset, | ||
4718 | _eina_value_type_int64_pset, | ||
4719 | _eina_value_type_int64_pget | ||
4720 | }, | ||
4721 | { | ||
4722 | EINA_VALUE_TYPE_VERSION, | ||
4723 | sizeof(float), | ||
4724 | "float", | ||
4725 | _eina_value_type_float_setup, | ||
4726 | _eina_value_type_float_flush, | ||
4727 | _eina_value_type_float_copy, | ||
4728 | _eina_value_type_float_compare, | ||
4729 | _eina_value_type_float_convert_to, | ||
4730 | NULL, /* no convert from */ | ||
4731 | _eina_value_type_float_vset, | ||
4732 | _eina_value_type_float_pset, | ||
4733 | _eina_value_type_float_pget | ||
4734 | }, | ||
4735 | { | ||
4736 | EINA_VALUE_TYPE_VERSION, | ||
4737 | sizeof(double), | ||
4738 | "double", | ||
4739 | _eina_value_type_double_setup, | ||
4740 | _eina_value_type_double_flush, | ||
4741 | _eina_value_type_double_copy, | ||
4742 | _eina_value_type_double_compare, | ||
4743 | _eina_value_type_double_convert_to, | ||
4744 | NULL, /* no convert from */ | ||
4745 | _eina_value_type_double_vset, | ||
4746 | _eina_value_type_double_pset, | ||
4747 | _eina_value_type_double_pget | ||
4748 | }, | ||
4749 | { | ||
4750 | EINA_VALUE_TYPE_VERSION, | ||
4751 | sizeof(const char *), | ||
4752 | "stringshare", | ||
4753 | _eina_value_type_string_common_setup, | ||
4754 | _eina_value_type_stringshare_flush, | ||
4755 | _eina_value_type_stringshare_copy, | ||
4756 | _eina_value_type_string_common_compare, | ||
4757 | _eina_value_type_string_common_convert_to, | ||
4758 | NULL, /* no convert from */ | ||
4759 | _eina_value_type_stringshare_vset, | ||
4760 | _eina_value_type_stringshare_pset, | ||
4761 | _eina_value_type_string_common_pget | ||
4762 | }, | ||
4763 | { | ||
4764 | EINA_VALUE_TYPE_VERSION, | ||
4765 | sizeof(char *), | ||
4766 | "string", | ||
4767 | _eina_value_type_string_common_setup, | ||
4768 | _eina_value_type_string_flush, | ||
4769 | _eina_value_type_string_copy, | ||
4770 | _eina_value_type_string_common_compare, | ||
4771 | _eina_value_type_string_common_convert_to, | ||
4772 | NULL, /* no convert from */ | ||
4773 | _eina_value_type_string_vset, | ||
4774 | _eina_value_type_string_pset, | ||
4775 | _eina_value_type_string_common_pget | ||
4776 | }, | ||
4777 | { | ||
4778 | EINA_VALUE_TYPE_VERSION, | ||
4779 | sizeof(unsigned long), | ||
4780 | "timestamp", | ||
4781 | _eina_value_type_ulong_setup, | ||
4782 | _eina_value_type_ulong_flush, | ||
4783 | _eina_value_type_ulong_copy, | ||
4784 | _eina_value_type_ulong_compare, | ||
4785 | _eina_value_type_ulong_convert_to, | ||
4786 | NULL, /* no convert from */ | ||
4787 | _eina_value_type_ulong_vset, | ||
4788 | _eina_value_type_ulong_pset, | ||
4789 | _eina_value_type_ulong_pget | ||
4790 | } | ||
4791 | }; | ||
4792 | |||
4793 | static void | ||
4794 | _eina_value_blob_operations_malloc_free(const Eina_Value_Blob_Operations *ops __UNUSED__, void *memory, size_t size __UNUSED__) | ||
4795 | { | ||
4796 | free(memory); | ||
4797 | } | ||
4798 | |||
4799 | static void * | ||
4800 | _eina_value_blob_operations_malloc_copy(const Eina_Value_Blob_Operations *ops __UNUSED__, const void *memory, size_t size) | ||
4801 | { | ||
4802 | void *ret = malloc(size); | ||
4803 | if (!ret) | ||
4804 | { | ||
4805 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
4806 | return NULL; | ||
4807 | } | ||
4808 | memcpy(ret, memory, size); | ||
4809 | return ret; | ||
4810 | } | ||
4811 | |||
4812 | static const Eina_Value_Blob_Operations _EINA_VALUE_BLOB_OPERATIONS_MALLOC = { | ||
4813 | EINA_VALUE_BLOB_OPERATIONS_VERSION, | ||
4814 | _eina_value_blob_operations_malloc_free, | ||
4815 | _eina_value_blob_operations_malloc_copy, | ||
4816 | NULL, | ||
4817 | NULL | ||
4818 | }; | ||
4819 | |||
4820 | typedef struct _Eina_Value_Inner_Mp Eina_Value_Inner_Mp; | ||
4821 | struct _Eina_Value_Inner_Mp | ||
4822 | { | ||
4823 | Eina_Mempool *mempool; | ||
4824 | int references; | ||
4825 | }; | ||
4826 | |||
4827 | /** | ||
4828 | * @endcond | ||
4829 | */ | ||
4830 | |||
4831 | static const char EINA_ERROR_VALUE_FAILED_STR[] = "Value check failed."; | ||
4832 | |||
4833 | /** | ||
4834 | */ | ||
4835 | |||
4836 | static inline void | ||
4837 | _eina_value_inner_mp_dispose(int size, Eina_Value_Inner_Mp *imp) | ||
4838 | { | ||
4839 | EINA_SAFETY_ON_FALSE_RETURN(imp->references == 0); | ||
4840 | |||
4841 | eina_hash_del_by_key(_eina_value_inner_mps, &size); | ||
4842 | eina_mempool_del(imp->mempool); | ||
4843 | free(imp); | ||
4844 | } | ||
4845 | |||
4846 | static inline Eina_Value_Inner_Mp * | ||
4847 | _eina_value_inner_mp_get(int size) | ||
4848 | { | ||
4849 | Eina_Value_Inner_Mp *imp = eina_hash_find(_eina_value_inner_mps, &size); | ||
4850 | if (imp) return imp; | ||
4851 | |||
4852 | imp = malloc(sizeof(Eina_Value_Inner_Mp)); | ||
4853 | if (!imp) | ||
4854 | return NULL; | ||
4855 | |||
4856 | imp->references = 0; | ||
4857 | |||
4858 | imp->mempool = eina_mempool_add(_eina_value_mp_choice, | ||
4859 | "Eina_Value_Inner_Mp", NULL, size, 128); | ||
4860 | if (!imp->mempool) | ||
4861 | { | ||
4862 | free(imp); | ||
4863 | return NULL; | ||
4864 | } | ||
4865 | |||
4866 | if (!eina_hash_add(_eina_value_inner_mps, &size, imp)) | ||
4867 | { | ||
4868 | eina_mempool_del(imp->mempool); | ||
4869 | free(imp); | ||
4870 | return NULL; | ||
4871 | } | ||
4872 | |||
4873 | return imp; | ||
4874 | } | ||
4875 | |||
4876 | static inline void * | ||
4877 | _eina_value_inner_alloc_internal(int size) | ||
4878 | { | ||
4879 | Eina_Value_Inner_Mp *imp; | ||
4880 | void *mem; | ||
4881 | |||
4882 | imp = _eina_value_inner_mp_get(size); | ||
4883 | if (!imp) return NULL; | ||
4884 | |||
4885 | mem = eina_mempool_malloc(imp->mempool, size); | ||
4886 | if (mem) imp->references++; | ||
4887 | else if (imp->references == 0) _eina_value_inner_mp_dispose(size, imp); | ||
4888 | |||
4889 | return mem; | ||
4890 | } | ||
4891 | |||
4892 | static inline void | ||
4893 | _eina_value_inner_free_internal(int size, void *mem) | ||
4894 | { | ||
4895 | Eina_Value_Inner_Mp *imp = eina_hash_find(_eina_value_inner_mps, &size); | ||
4896 | EINA_SAFETY_ON_NULL_RETURN(imp); | ||
4897 | |||
4898 | eina_mempool_free(imp->mempool, mem); | ||
4899 | |||
4900 | imp->references--; | ||
4901 | if (imp->references > 0) return; | ||
4902 | _eina_value_inner_mp_dispose(size, imp); | ||
4903 | } | ||
4904 | |||
4905 | EAPI void * | ||
4906 | eina_value_inner_alloc(size_t size) | ||
4907 | { | ||
4908 | void *mem; | ||
4909 | |||
4910 | if (size > 256) return malloc(size); | ||
4911 | |||
4912 | eina_lock_take(&_eina_value_inner_mps_lock); | ||
4913 | mem = _eina_value_inner_alloc_internal(size); | ||
4914 | eina_lock_release(&_eina_value_inner_mps_lock); | ||
4915 | |||
4916 | return mem; | ||
4917 | } | ||
4918 | |||
4919 | EAPI void | ||
4920 | eina_value_inner_free(size_t size, void *mem) | ||
4921 | { | ||
4922 | if (size > 256) | ||
4923 | { | ||
4924 | free(mem); | ||
4925 | return; | ||
4926 | } | ||
4927 | |||
4928 | eina_lock_take(&_eina_value_inner_mps_lock); | ||
4929 | _eina_value_inner_free_internal(size, mem); | ||
4930 | eina_lock_release(&_eina_value_inner_mps_lock); | ||
4931 | } | ||
4932 | |||
4933 | /** | ||
4934 | * @internal | ||
4935 | * @brief Initialize the value module. | ||
4936 | * | ||
4937 | * @return #EINA_TRUE on success, #EINA_FALSE on failure. | ||
4938 | * | ||
4939 | * This function sets up the value module of Eina. It is called | ||
4940 | * by eina_init(). | ||
4941 | * | ||
4942 | * @see eina_init() | ||
4943 | */ | ||
4944 | Eina_Bool | ||
4945 | eina_value_init(void) | ||
4946 | { | ||
4947 | const char *choice, *tmp; | ||
4948 | |||
4949 | _eina_value_log_dom = eina_log_domain_register("eina_value", | ||
4950 | EINA_LOG_COLOR_DEFAULT); | ||
4951 | if (_eina_value_log_dom < 0) | ||
4952 | { | ||
4953 | EINA_LOG_ERR("Could not register log domain: eina_value"); | ||
4954 | return EINA_FALSE; | ||
4955 | } | ||
4956 | |||
4957 | #ifdef EINA_DEFAULT_MEMPOOL | ||
4958 | choice = "pass_through"; | ||
4959 | #else | ||
4960 | choice = "chained_mempool"; | ||
4961 | #endif | ||
4962 | tmp = getenv("EINA_MEMPOOL"); | ||
4963 | if (tmp && tmp[0]) | ||
4964 | choice = tmp; | ||
4965 | |||
4966 | if (choice) | ||
4967 | _eina_value_mp_choice = strdup(choice); | ||
4968 | |||
4969 | _eina_value_mp = eina_mempool_add | ||
4970 | (_eina_value_mp_choice, "value", NULL, sizeof(Eina_Value), 320); | ||
4971 | if (!_eina_value_mp) | ||
4972 | { | ||
4973 | ERR("Mempool for value cannot be allocated in value init."); | ||
4974 | goto on_init_fail_mp; | ||
4975 | } | ||
4976 | |||
4977 | if (!eina_lock_new(&_eina_value_inner_mps_lock)) | ||
4978 | { | ||
4979 | ERR("Cannot create lock in value init."); | ||
4980 | goto on_init_fail_lock; | ||
4981 | } | ||
4982 | _eina_value_inner_mps = eina_hash_int32_new(NULL); | ||
4983 | if (!_eina_value_inner_mps) | ||
4984 | { | ||
4985 | ERR("Cannot create hash for inner mempools in value init."); | ||
4986 | goto on_init_fail_hash; | ||
4987 | } | ||
4988 | |||
4989 | EINA_ERROR_VALUE_FAILED = eina_error_msg_static_register( | ||
4990 | EINA_ERROR_VALUE_FAILED_STR); | ||
4991 | |||
4992 | EINA_VALUE_TYPE_UCHAR = _EINA_VALUE_TYPE_BASICS + 0; | ||
4993 | EINA_VALUE_TYPE_USHORT = _EINA_VALUE_TYPE_BASICS + 1; | ||
4994 | EINA_VALUE_TYPE_UINT = _EINA_VALUE_TYPE_BASICS + 2; | ||
4995 | EINA_VALUE_TYPE_ULONG = _EINA_VALUE_TYPE_BASICS + 3; | ||
4996 | EINA_VALUE_TYPE_UINT64 = _EINA_VALUE_TYPE_BASICS + 4; | ||
4997 | EINA_VALUE_TYPE_CHAR = _EINA_VALUE_TYPE_BASICS + 5; | ||
4998 | EINA_VALUE_TYPE_SHORT = _EINA_VALUE_TYPE_BASICS + 6; | ||
4999 | EINA_VALUE_TYPE_INT = _EINA_VALUE_TYPE_BASICS + 7; | ||
5000 | EINA_VALUE_TYPE_LONG = _EINA_VALUE_TYPE_BASICS + 8; | ||
5001 | EINA_VALUE_TYPE_INT64 = _EINA_VALUE_TYPE_BASICS + 9; | ||
5002 | EINA_VALUE_TYPE_FLOAT = _EINA_VALUE_TYPE_BASICS + 10; | ||
5003 | EINA_VALUE_TYPE_DOUBLE = _EINA_VALUE_TYPE_BASICS + 11; | ||
5004 | EINA_VALUE_TYPE_STRINGSHARE = _EINA_VALUE_TYPE_BASICS + 12; | ||
5005 | EINA_VALUE_TYPE_STRING = _EINA_VALUE_TYPE_BASICS + 13; | ||
5006 | EINA_VALUE_TYPE_TIMESTAMP = _EINA_VALUE_TYPE_BASICS + 14; | ||
5007 | |||
5008 | _EINA_VALUE_TYPE_BASICS_START = _EINA_VALUE_TYPE_BASICS + 0; | ||
5009 | _EINA_VALUE_TYPE_BASICS_END = _EINA_VALUE_TYPE_BASICS + 14; | ||
5010 | |||
5011 | EINA_SAFETY_ON_FALSE_RETURN_VAL((sizeof(_EINA_VALUE_TYPE_BASICS)/sizeof(_EINA_VALUE_TYPE_BASICS[0])) == 15, EINA_FALSE); | ||
5012 | |||
5013 | |||
5014 | EINA_VALUE_TYPE_ARRAY = &_EINA_VALUE_TYPE_ARRAY; | ||
5015 | EINA_VALUE_TYPE_LIST = &_EINA_VALUE_TYPE_LIST; | ||
5016 | EINA_VALUE_TYPE_HASH = &_EINA_VALUE_TYPE_HASH; | ||
5017 | EINA_VALUE_TYPE_TIMEVAL = &_EINA_VALUE_TYPE_TIMEVAL; | ||
5018 | EINA_VALUE_TYPE_BLOB = &_EINA_VALUE_TYPE_BLOB; | ||
5019 | EINA_VALUE_TYPE_STRUCT = &_EINA_VALUE_TYPE_STRUCT; | ||
5020 | EINA_VALUE_TYPE_MODEL = &_EINA_VALUE_TYPE_MODEL; | ||
5021 | |||
5022 | EINA_VALUE_BLOB_OPERATIONS_MALLOC = &_EINA_VALUE_BLOB_OPERATIONS_MALLOC; | ||
5023 | |||
5024 | EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH = &_EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH; | ||
5025 | EINA_VALUE_STRUCT_OPERATIONS_STRINGSHARE = &_EINA_VALUE_STRUCT_OPERATIONS_STRINGSHARE; | ||
5026 | |||
5027 | return EINA_TRUE; | ||
5028 | |||
5029 | on_init_fail_hash: | ||
5030 | eina_lock_free(&_eina_value_inner_mps_lock); | ||
5031 | on_init_fail_lock: | ||
5032 | eina_mempool_del(_eina_value_mp); | ||
5033 | on_init_fail_mp: | ||
5034 | free(_eina_value_mp_choice); | ||
5035 | _eina_value_mp_choice = NULL; | ||
5036 | eina_log_domain_unregister(_eina_value_log_dom); | ||
5037 | _eina_value_log_dom = -1; | ||
5038 | return EINA_FALSE; | ||
5039 | } | ||
5040 | |||
5041 | /** | ||
5042 | * @internal | ||
5043 | * @brief Shut down the value module. | ||
5044 | * | ||
5045 | * @return #EINA_TRUE on success, #EINA_FALSE on failure. | ||
5046 | * | ||
5047 | * This function shuts down the value module set up by | ||
5048 | * eina_value_init(). It is called by eina_shutdown(). | ||
5049 | * | ||
5050 | * @see eina_shutdown() | ||
5051 | */ | ||
5052 | Eina_Bool | ||
5053 | eina_value_shutdown(void) | ||
5054 | { | ||
5055 | eina_lock_take(&_eina_value_inner_mps_lock); | ||
5056 | if (eina_hash_population(_eina_value_inner_mps) != 0) | ||
5057 | ERR("Cannot free eina_value internal memory pools -- still in use!"); | ||
5058 | else | ||
5059 | eina_hash_free(_eina_value_inner_mps); | ||
5060 | eina_lock_release(&_eina_value_inner_mps_lock); | ||
5061 | eina_lock_free(&_eina_value_inner_mps_lock); | ||
5062 | |||
5063 | free(_eina_value_mp_choice); | ||
5064 | _eina_value_mp_choice = NULL; | ||
5065 | eina_mempool_del(_eina_value_mp); | ||
5066 | eina_log_domain_unregister(_eina_value_log_dom); | ||
5067 | _eina_value_log_dom = -1; | ||
5068 | return EINA_TRUE; | ||
5069 | } | ||
5070 | |||
5071 | /*============================================================================* | ||
5072 | * Global * | ||
5073 | *============================================================================*/ | ||
5074 | |||
5075 | /*============================================================================* | ||
5076 | * API * | ||
5077 | *============================================================================*/ | ||
5078 | |||
5079 | EAPI const Eina_Value_Type *_EINA_VALUE_TYPE_BASICS_START = NULL; | ||
5080 | EAPI const Eina_Value_Type *_EINA_VALUE_TYPE_BASICS_END = NULL; | ||
5081 | |||
5082 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UCHAR = NULL; | ||
5083 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_USHORT = NULL; | ||
5084 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UINT = NULL; | ||
5085 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_ULONG = NULL; | ||
5086 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_TIMESTAMP = NULL; | ||
5087 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UINT64 = NULL; | ||
5088 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_CHAR = NULL; | ||
5089 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_SHORT = NULL; | ||
5090 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_INT = NULL; | ||
5091 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_LONG = NULL; | ||
5092 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_INT64 = NULL; | ||
5093 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_FLOAT = NULL; | ||
5094 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_DOUBLE = NULL; | ||
5095 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_STRINGSHARE = NULL; | ||
5096 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_STRING = NULL; | ||
5097 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_ARRAY = NULL; | ||
5098 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_LIST = NULL; | ||
5099 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_HASH = NULL; | ||
5100 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_TIMEVAL = NULL; | ||
5101 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_BLOB = NULL; | ||
5102 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_STRUCT = NULL; | ||
5103 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_MODEL = NULL; | ||
5104 | |||
5105 | EAPI const Eina_Value_Blob_Operations *EINA_VALUE_BLOB_OPERATIONS_MALLOC = NULL; | ||
5106 | |||
5107 | EAPI const Eina_Value_Struct_Operations *EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH = NULL; | ||
5108 | EAPI const Eina_Value_Struct_Operations *EINA_VALUE_STRUCT_OPERATIONS_STRINGSHARE = NULL; | ||
5109 | |||
5110 | EAPI Eina_Error EINA_ERROR_VALUE_FAILED = 0; | ||
5111 | |||
5112 | EAPI const unsigned int eina_prime_table[] = | ||
5113 | { | ||
5114 | 17, 31, 61, 127, 257, 509, 1021, | ||
5115 | 2053, 4093, 8191, 16381, 32771, 65537, 131071, 262147, 524287, 1048573, | ||
5116 | 2097143, 4194301, 8388617, 16777213 | ||
5117 | }; | ||
5118 | |||
5119 | EAPI Eina_Value * | ||
5120 | eina_value_new(const Eina_Value_Type *type) | ||
5121 | { | ||
5122 | Eina_Value *value = eina_mempool_malloc(_eina_value_mp, sizeof(Eina_Value));; | ||
5123 | if (!value) | ||
5124 | { | ||
5125 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | ||
5126 | return NULL; | ||
5127 | } | ||
5128 | if (!eina_value_setup(value, type)) | ||
5129 | { | ||
5130 | free(value); | ||
5131 | return NULL; | ||
5132 | } | ||
5133 | return value; | ||
5134 | } | ||
5135 | |||
5136 | EAPI void | ||
5137 | eina_value_free(Eina_Value *value) | ||
5138 | { | ||
5139 | EINA_SAFETY_ON_NULL_RETURN(value); | ||
5140 | eina_value_flush(value); | ||
5141 | eina_mempool_free(_eina_value_mp, value); | ||
5142 | } | ||
5143 | |||
5144 | |||
5145 | EAPI Eina_Bool | ||
5146 | eina_value_copy(const Eina_Value *value, Eina_Value *copy) | ||
5147 | { | ||
5148 | const Eina_Value_Type *type; | ||
5149 | const void *src; | ||
5150 | void *dst; | ||
5151 | Eina_Bool ret; | ||
5152 | |||
5153 | EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE); | ||
5154 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(value->type), | ||
5155 | EINA_FALSE); | ||
5156 | EINA_SAFETY_ON_NULL_RETURN_VAL(copy, EINA_FALSE); | ||
5157 | EINA_SAFETY_ON_NULL_RETURN_VAL(value->type->copy, EINA_FALSE); | ||
5158 | |||
5159 | type = value->type; | ||
5160 | if (!eina_value_setup(copy, type)) | ||
5161 | return EINA_FALSE; | ||
5162 | |||
5163 | src = eina_value_memory_get(value); | ||
5164 | dst = eina_value_memory_get(copy); | ||
5165 | ret = type->copy(type, src, dst); | ||
5166 | if (!ret) | ||
5167 | eina_value_flush(copy); | ||
5168 | |||
5169 | return ret; | ||
5170 | } | ||
5171 | |||
5172 | EAPI Eina_Bool | ||
5173 | eina_value_convert(const Eina_Value *value, Eina_Value *convert) | ||
5174 | { | ||
5175 | Eina_Bool ret = EINA_FALSE; | ||
5176 | const Eina_Value_Type *type, *convert_type; | ||
5177 | const void *type_mem; | ||
5178 | void *convert_mem; | ||
5179 | |||
5180 | EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE); | ||
5181 | EINA_SAFETY_ON_NULL_RETURN_VAL(convert, EINA_FALSE); | ||
5182 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(value->type), | ||
5183 | EINA_FALSE); | ||
5184 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(convert->type), | ||
5185 | EINA_FALSE); | ||
5186 | |||
5187 | type = value->type; | ||
5188 | convert_type = convert->type; | ||
5189 | |||
5190 | type_mem = eina_value_memory_get(value); | ||
5191 | convert_mem = eina_value_memory_get(convert); | ||
5192 | |||
5193 | if (type->convert_to) | ||
5194 | ret = type->convert_to(type, convert_type, type_mem, convert_mem); | ||
5195 | |||
5196 | if ((!ret) && (convert_type->convert_from)) | ||
5197 | ret = convert_type->convert_from(convert_type, type, convert_mem, | ||
5198 | type_mem); | ||
5199 | |||
5200 | return ret; | ||
5201 | } | ||
5202 | |||
5203 | EAPI char * | ||
5204 | eina_value_to_string(const Eina_Value *value) | ||
5205 | { | ||
5206 | Eina_Value tmp; | ||
5207 | |||
5208 | EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL); | ||
5209 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(value->type), NULL); | ||
5210 | |||
5211 | if (!eina_value_setup(&tmp, EINA_VALUE_TYPE_STRING)) | ||
5212 | return NULL; | ||
5213 | if (!eina_value_convert(value, &tmp)) | ||
5214 | return NULL; | ||
5215 | |||
5216 | return tmp.value.ptr; /* steal value */ | ||
5217 | } | ||
5218 | |||
5219 | EAPI Eina_Value * | ||
5220 | eina_value_array_new(const Eina_Value_Type *subtype, unsigned int step) | ||
5221 | { | ||
5222 | Eina_Value *value; | ||
5223 | |||
5224 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(subtype), EINA_FALSE); | ||
5225 | |||
5226 | value = eina_mempool_malloc(_eina_value_mp, sizeof(Eina_Value));; | ||
5227 | if (!value) | ||
5228 | return NULL; | ||
5229 | |||
5230 | if (!eina_value_array_setup(value, subtype, step)) | ||
5231 | { | ||
5232 | eina_mempool_free(_eina_value_mp, value); | ||
5233 | return NULL; | ||
5234 | } | ||
5235 | |||
5236 | return value; | ||
5237 | } | ||
5238 | |||
5239 | EAPI Eina_Value * | ||
5240 | eina_value_list_new(const Eina_Value_Type *subtype) | ||
5241 | { | ||
5242 | Eina_Value *value; | ||
5243 | |||
5244 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(subtype), EINA_FALSE); | ||
5245 | |||
5246 | value = eina_mempool_malloc(_eina_value_mp, sizeof(Eina_Value));; | ||
5247 | if (!value) | ||
5248 | return NULL; | ||
5249 | |||
5250 | if (!eina_value_list_setup(value, subtype)) | ||
5251 | { | ||
5252 | eina_mempool_free(_eina_value_mp, value); | ||
5253 | return NULL; | ||
5254 | } | ||
5255 | |||
5256 | return value; | ||
5257 | } | ||
5258 | |||
5259 | EAPI Eina_Value * | ||
5260 | eina_value_hash_new(const Eina_Value_Type *subtype, unsigned int buckets_power_size) | ||
5261 | { | ||
5262 | Eina_Value *value; | ||
5263 | |||
5264 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(subtype), EINA_FALSE); | ||
5265 | |||
5266 | value = eina_mempool_malloc(_eina_value_mp, sizeof(Eina_Value));; | ||
5267 | if (!value) | ||
5268 | return NULL; | ||
5269 | |||
5270 | if (!eina_value_hash_setup(value, subtype, buckets_power_size)) | ||
5271 | { | ||
5272 | eina_mempool_free(_eina_value_mp, value); | ||
5273 | return NULL; | ||
5274 | } | ||
5275 | |||
5276 | return value; | ||
5277 | } | ||
5278 | |||
5279 | EAPI Eina_Value * | ||
5280 | eina_value_struct_new(const Eina_Value_Struct_Desc *desc) | ||
5281 | { | ||
5282 | Eina_Value *value; | ||
5283 | |||
5284 | value = eina_mempool_malloc(_eina_value_mp, sizeof(Eina_Value));; | ||
5285 | if (!value) | ||
5286 | return NULL; | ||
5287 | |||
5288 | if (!eina_value_struct_setup(value, desc)) | ||
5289 | { | ||
5290 | eina_mempool_free(_eina_value_mp, value); | ||
5291 | return NULL; | ||
5292 | } | ||
5293 | |||
5294 | return value; | ||
5295 | } | ||
5296 | |||
5297 | EAPI Eina_Bool | ||
5298 | eina_value_type_check(const Eina_Value_Type *type) | ||
5299 | { | ||
5300 | EINA_SAFETY_ON_NULL_RETURN_VAL(type, EINA_FALSE); | ||
5301 | return type->version == EINA_VALUE_TYPE_VERSION; | ||
5302 | } | ||
5303 | |||
5304 | EAPI const char * | ||
5305 | eina_value_type_name_get(const Eina_Value_Type *type) | ||
5306 | { | ||
5307 | EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_check(type), NULL); | ||
5308 | return type->name; | ||
5309 | } | ||