diff options
author | David Walter Seikel | 2012-04-22 09:19:23 +1000 |
---|---|---|
committer | David Walter Seikel | 2012-04-22 09:19:23 +1000 |
commit | c963d75dfdeec11f82e79e727062fbf89afa2c04 (patch) | |
tree | 895633dbf641110be46f117c29890c49b3ffc0bd /libraries/eina/src/lib/eina_value.c | |
parent | Adding the new extantz viewer and grid manager. (diff) | |
download | SledjHamr-c963d75dfdeec11f82e79e727062fbf89afa2c04.zip SledjHamr-c963d75dfdeec11f82e79e727062fbf89afa2c04.tar.gz SledjHamr-c963d75dfdeec11f82e79e727062fbf89afa2c04.tar.bz2 SledjHamr-c963d75dfdeec11f82e79e727062fbf89afa2c04.tar.xz |
Update EFL to latest beta.
Diffstat (limited to '')
-rw-r--r-- | libraries/eina/src/lib/eina_value.c | 453 |
1 files changed, 369 insertions, 84 deletions
diff --git a/libraries/eina/src/lib/eina_value.c b/libraries/eina/src/lib/eina_value.c index ba8af52..b8df693 100644 --- a/libraries/eina/src/lib/eina_value.c +++ b/libraries/eina/src/lib/eina_value.c | |||
@@ -49,6 +49,10 @@ void *alloca (size_t); | |||
49 | #include <inttypes.h> /* PRId64 and PRIu64 */ | 49 | #include <inttypes.h> /* PRId64 and PRIu64 */ |
50 | #include <sys/time.h> /* struct timeval */ | 50 | #include <sys/time.h> /* struct timeval */ |
51 | 51 | ||
52 | #ifdef HAVE_EVIL | ||
53 | # include <Evil.h> | ||
54 | #endif | ||
55 | |||
52 | #include "eina_config.h" | 56 | #include "eina_config.h" |
53 | #include "eina_private.h" | 57 | #include "eina_private.h" |
54 | #include "eina_error.h" | 58 | #include "eina_error.h" |
@@ -60,6 +64,7 @@ void *alloca (size_t); | |||
60 | /* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */ | 64 | /* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */ |
61 | #include "eina_safety_checks.h" | 65 | #include "eina_safety_checks.h" |
62 | #include "eina_value.h" | 66 | #include "eina_value.h" |
67 | #include "eina_model.h" /* uses eina_value.h */ | ||
63 | 68 | ||
64 | /*============================================================================* | 69 | /*============================================================================* |
65 | * Local * | 70 | * Local * |
@@ -168,7 +173,7 @@ _eina_value_type_uchar_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
168 | unsigned int other_mem = v; | 173 | unsigned int other_mem = v; |
169 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 174 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
170 | } | 175 | } |
171 | else if (convert == EINA_VALUE_TYPE_ULONG) | 176 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
172 | { | 177 | { |
173 | unsigned long other_mem = v; | 178 | unsigned long other_mem = v; |
174 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 179 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
@@ -317,7 +322,7 @@ _eina_value_type_ushort_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
317 | unsigned int other_mem = v; | 322 | unsigned int other_mem = v; |
318 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 323 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
319 | } | 324 | } |
320 | else if (convert == EINA_VALUE_TYPE_ULONG) | 325 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
321 | { | 326 | { |
322 | unsigned long other_mem = v; | 327 | unsigned long other_mem = v; |
323 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 328 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
@@ -470,7 +475,7 @@ _eina_value_type_uint_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
470 | unsigned int other_mem = v; | 475 | unsigned int other_mem = v; |
471 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 476 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
472 | } | 477 | } |
473 | else if (convert == EINA_VALUE_TYPE_ULONG) | 478 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
474 | { | 479 | { |
475 | unsigned long other_mem = v; | 480 | unsigned long other_mem = v; |
476 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 481 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
@@ -627,7 +632,7 @@ _eina_value_type_ulong_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
627 | return EINA_FALSE; | 632 | return EINA_FALSE; |
628 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 633 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
629 | } | 634 | } |
630 | else if (convert == EINA_VALUE_TYPE_ULONG) | 635 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
631 | { | 636 | { |
632 | unsigned long other_mem = v; | 637 | unsigned long other_mem = v; |
633 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 638 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
@@ -786,7 +791,7 @@ _eina_value_type_uint64_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
786 | return EINA_FALSE; | 791 | return EINA_FALSE; |
787 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 792 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
788 | } | 793 | } |
789 | else if (convert == EINA_VALUE_TYPE_ULONG) | 794 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
790 | { | 795 | { |
791 | unsigned long other_mem = v; | 796 | unsigned long other_mem = v; |
792 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && | 797 | if (EINA_UNLIKELY((sizeof(other_mem) != sizeof(v)) && |
@@ -950,7 +955,7 @@ _eina_value_type_char_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
950 | return EINA_FALSE; | 955 | return EINA_FALSE; |
951 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 956 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
952 | } | 957 | } |
953 | else if (convert == EINA_VALUE_TYPE_ULONG) | 958 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
954 | { | 959 | { |
955 | unsigned long other_mem = v; | 960 | unsigned long other_mem = v; |
956 | if (EINA_UNLIKELY(v < 0)) | 961 | if (EINA_UNLIKELY(v < 0)) |
@@ -1107,7 +1112,7 @@ _eina_value_type_short_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
1107 | return EINA_FALSE; | 1112 | return EINA_FALSE; |
1108 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 1113 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
1109 | } | 1114 | } |
1110 | else if (convert == EINA_VALUE_TYPE_ULONG) | 1115 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
1111 | { | 1116 | { |
1112 | unsigned long other_mem = v; | 1117 | unsigned long other_mem = v; |
1113 | if (EINA_UNLIKELY(v < 0)) | 1118 | if (EINA_UNLIKELY(v < 0)) |
@@ -1270,7 +1275,7 @@ _eina_value_type_int_convert_to(const Eina_Value_Type *type __UNUSED__, const Ei | |||
1270 | return EINA_FALSE; | 1275 | return EINA_FALSE; |
1271 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 1276 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
1272 | } | 1277 | } |
1273 | else if (convert == EINA_VALUE_TYPE_ULONG) | 1278 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
1274 | { | 1279 | { |
1275 | unsigned long other_mem = v; | 1280 | unsigned long other_mem = v; |
1276 | if (EINA_UNLIKELY(v < 0)) | 1281 | if (EINA_UNLIKELY(v < 0)) |
@@ -1439,7 +1444,7 @@ _eina_value_type_long_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
1439 | return EINA_FALSE; | 1444 | return EINA_FALSE; |
1440 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 1445 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
1441 | } | 1446 | } |
1442 | else if (convert == EINA_VALUE_TYPE_ULONG) | 1447 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
1443 | { | 1448 | { |
1444 | unsigned long other_mem = v; | 1449 | unsigned long other_mem = v; |
1445 | if (EINA_UNLIKELY(v < 0)) | 1450 | if (EINA_UNLIKELY(v < 0)) |
@@ -1612,7 +1617,7 @@ _eina_value_type_int64_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
1612 | return EINA_FALSE; | 1617 | return EINA_FALSE; |
1613 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 1618 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
1614 | } | 1619 | } |
1615 | else if (convert == EINA_VALUE_TYPE_ULONG) | 1620 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
1616 | { | 1621 | { |
1617 | unsigned long other_mem = v; | 1622 | unsigned long other_mem = v; |
1618 | if (EINA_UNLIKELY(v < 0)) | 1623 | if (EINA_UNLIKELY(v < 0)) |
@@ -1792,7 +1797,7 @@ _eina_value_type_float_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
1792 | return EINA_FALSE; | 1797 | return EINA_FALSE; |
1793 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 1798 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
1794 | } | 1799 | } |
1795 | else if (convert == EINA_VALUE_TYPE_ULONG) | 1800 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
1796 | { | 1801 | { |
1797 | unsigned long other_mem = v; | 1802 | unsigned long other_mem = v; |
1798 | if (EINA_UNLIKELY(v < 0)) | 1803 | if (EINA_UNLIKELY(v < 0)) |
@@ -1978,7 +1983,7 @@ _eina_value_type_double_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
1978 | return EINA_FALSE; | 1983 | return EINA_FALSE; |
1979 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 1984 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
1980 | } | 1985 | } |
1981 | else if (convert == EINA_VALUE_TYPE_ULONG) | 1986 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
1982 | { | 1987 | { |
1983 | unsigned long other_mem = v; | 1988 | unsigned long other_mem = v; |
1984 | if (EINA_UNLIKELY(v < 0)) | 1989 | if (EINA_UNLIKELY(v < 0)) |
@@ -2146,7 +2151,7 @@ _eina_value_type_string_common_convert_to(const Eina_Value_Type *type __UNUSED__ | |||
2146 | return EINA_FALSE; | 2151 | return EINA_FALSE; |
2147 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 2152 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
2148 | } | 2153 | } |
2149 | else if (convert == EINA_VALUE_TYPE_ULONG) | 2154 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
2150 | { | 2155 | { |
2151 | unsigned long other_mem; | 2156 | unsigned long other_mem; |
2152 | if ((sscanf(v, "%lu", &other_mem) != 1) && | 2157 | if ((sscanf(v, "%lu", &other_mem) != 1) && |
@@ -2248,7 +2253,11 @@ static Eina_Bool | |||
2248 | _eina_value_type_stringshare_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | 2253 | _eina_value_type_stringshare_flush(const Eina_Value_Type *type __UNUSED__, void *mem) |
2249 | { | 2254 | { |
2250 | const char **tmem = mem; | 2255 | const char **tmem = mem; |
2251 | if (*tmem) eina_stringshare_del(*tmem); | 2256 | if (*tmem) |
2257 | { | ||
2258 | eina_stringshare_del(*tmem); | ||
2259 | *tmem = NULL; | ||
2260 | } | ||
2252 | return EINA_TRUE; | 2261 | return EINA_TRUE; |
2253 | } | 2262 | } |
2254 | 2263 | ||
@@ -2257,8 +2266,7 @@ _eina_value_type_stringshare_copy(const Eina_Value_Type *type __UNUSED__, const | |||
2257 | { | 2266 | { |
2258 | const char * const*s = src; | 2267 | const char * const*s = src; |
2259 | const char **d = dst; | 2268 | const char **d = dst; |
2260 | *d = *s; | 2269 | *d = eina_stringshare_add(*s); |
2261 | eina_stringshare_ref(*d); | ||
2262 | return EINA_TRUE; | 2270 | return EINA_TRUE; |
2263 | } | 2271 | } |
2264 | 2272 | ||
@@ -2280,7 +2288,11 @@ static Eina_Bool | |||
2280 | _eina_value_type_string_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | 2288 | _eina_value_type_string_flush(const Eina_Value_Type *type __UNUSED__, void *mem) |
2281 | { | 2289 | { |
2282 | char **tmem = mem; | 2290 | char **tmem = mem; |
2283 | if (*tmem) free(*tmem); | 2291 | if (*tmem) |
2292 | { | ||
2293 | free(*tmem); | ||
2294 | *tmem = NULL; | ||
2295 | } | ||
2284 | return EINA_TRUE; | 2296 | return EINA_TRUE; |
2285 | } | 2297 | } |
2286 | 2298 | ||
@@ -2308,19 +2320,24 @@ _eina_value_type_string_vset(const Eina_Value_Type *type __UNUSED__, void *mem, | |||
2308 | { | 2320 | { |
2309 | char **tmem = mem; | 2321 | char **tmem = mem; |
2310 | const char *str = va_arg(args, const char *); | 2322 | const char *str = va_arg(args, const char *); |
2311 | free(*tmem); | 2323 | eina_error_set(0); |
2312 | if (str == NULL) | 2324 | if (str == *tmem) return EINA_TRUE; |
2313 | *tmem = NULL; | 2325 | if (!str) |
2326 | { | ||
2327 | free(*tmem); | ||
2328 | *tmem = NULL; | ||
2329 | } | ||
2314 | else | 2330 | else |
2315 | { | 2331 | { |
2316 | *tmem = strdup(str); | 2332 | char *tmp = strdup(str); |
2317 | if (*tmem == NULL) | 2333 | if (!tmp) |
2318 | { | 2334 | { |
2319 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | 2335 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); |
2320 | return EINA_FALSE; | 2336 | return EINA_FALSE; |
2321 | } | 2337 | } |
2338 | free(*tmem); | ||
2339 | *tmem = tmp; | ||
2322 | } | 2340 | } |
2323 | eina_error_set(0); | ||
2324 | return EINA_TRUE; | 2341 | return EINA_TRUE; |
2325 | } | 2342 | } |
2326 | 2343 | ||
@@ -2329,19 +2346,24 @@ _eina_value_type_string_pset(const Eina_Value_Type *type __UNUSED__, void *mem, | |||
2329 | { | 2346 | { |
2330 | char **tmem = mem; | 2347 | char **tmem = mem; |
2331 | const char * const *str = ptr; | 2348 | const char * const *str = ptr; |
2332 | free(*tmem); | 2349 | eina_error_set(0); |
2333 | if (*str == NULL) | 2350 | if (*str == *tmem) return EINA_TRUE; |
2334 | *tmem = NULL; | 2351 | if (!*str) |
2352 | { | ||
2353 | free(*tmem); | ||
2354 | *tmem = NULL; | ||
2355 | } | ||
2335 | else | 2356 | else |
2336 | { | 2357 | { |
2337 | *tmem = strdup(*str); | 2358 | char *tmp = strdup(*str); |
2338 | if (*tmem == NULL) | 2359 | if (!tmp) |
2339 | { | 2360 | { |
2340 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | 2361 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); |
2341 | return EINA_FALSE; | 2362 | return EINA_FALSE; |
2342 | } | 2363 | } |
2364 | free(*tmem); | ||
2365 | *tmem = tmp; | ||
2343 | } | 2366 | } |
2344 | eina_error_set(0); | ||
2345 | return EINA_TRUE; | 2367 | return EINA_TRUE; |
2346 | } | 2368 | } |
2347 | 2369 | ||
@@ -2505,12 +2527,13 @@ _eina_value_type_array_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
2505 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | 2527 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) |
2506 | { | 2528 | { |
2507 | Eina_Strbuf *str = eina_strbuf_new(); | 2529 | Eina_Strbuf *str = eina_strbuf_new(); |
2530 | const char *ptr; | ||
2508 | if (!tmem->array) eina_strbuf_append(str, "[]"); | 2531 | if (!tmem->array) eina_strbuf_append(str, "[]"); |
2509 | else | 2532 | else |
2510 | { | 2533 | { |
2511 | const Eina_Value_Type *subtype = tmem->subtype; | 2534 | const Eina_Value_Type *subtype = tmem->subtype; |
2512 | unsigned char sz; | 2535 | unsigned char sz; |
2513 | const char *ptr, *ptr_end; | 2536 | const char *ptr_end; |
2514 | Eina_Value tmp; | 2537 | Eina_Value tmp; |
2515 | Eina_Bool first = EINA_TRUE; | 2538 | Eina_Bool first = EINA_TRUE; |
2516 | 2539 | ||
@@ -2551,10 +2574,10 @@ _eina_value_type_array_convert_to(const Eina_Value_Type *type __UNUSED__, const | |||
2551 | } | 2574 | } |
2552 | 2575 | ||
2553 | eina_strbuf_append_char(str, ']'); | 2576 | eina_strbuf_append_char(str, ']'); |
2554 | ptr = eina_strbuf_string_get(str); | ||
2555 | ret = eina_value_type_pset(convert, convert_mem, &ptr); | ||
2556 | eina_strbuf_free(str); | ||
2557 | } | 2577 | } |
2578 | ptr = eina_strbuf_string_get(str); | ||
2579 | ret = eina_value_type_pset(convert, convert_mem, &ptr); | ||
2580 | eina_strbuf_free(str); | ||
2558 | } | 2581 | } |
2559 | else if ((tmem->array) && (tmem->array->len == 1)) | 2582 | else if ((tmem->array) && (tmem->array->len == 1)) |
2560 | { | 2583 | { |
@@ -2606,43 +2629,51 @@ _eina_value_type_array_convert_from(const Eina_Value_Type *type, const Eina_Valu | |||
2606 | } | 2629 | } |
2607 | 2630 | ||
2608 | static Eina_Bool | 2631 | static Eina_Bool |
2609 | _eina_value_type_array_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | 2632 | _eina_value_type_array_pset(const Eina_Value_Type *type, void *mem, const void *ptr) |
2610 | { | 2633 | { |
2611 | Eina_Value_Array *tmem = mem; | 2634 | Eina_Value_Array *tmem = mem; |
2612 | const Eina_Value_Array *desc = ptr; | 2635 | const Eina_Value_Array *desc = ptr; |
2613 | Eina_Inarray *desc_array; | 2636 | Eina_Inarray *desc_array; |
2614 | 2637 | ||
2638 | eina_error_set(0); | ||
2615 | if ((!tmem->subtype) && (!desc->subtype)) | 2639 | if ((!tmem->subtype) && (!desc->subtype)) |
2616 | return EINA_TRUE; | 2640 | return EINA_TRUE; |
2617 | 2641 | ||
2618 | desc_array = desc->array; | 2642 | desc_array = desc->array; |
2619 | if (desc_array) | 2643 | if (desc_array) |
2620 | { | 2644 | { |
2645 | Eina_Value_Array tmp; | ||
2646 | |||
2621 | EINA_SAFETY_ON_FALSE_RETURN_VAL | 2647 | EINA_SAFETY_ON_FALSE_RETURN_VAL |
2622 | (desc_array->member_size == desc->subtype->value_size, EINA_FALSE); | 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; | ||
2623 | } | 2662 | } |
2624 | 2663 | ||
2625 | if (tmem->array) | 2664 | if (tmem->array) |
2626 | { | 2665 | { |
2627 | _eina_value_type_array_flush_elements(tmem); | 2666 | _eina_value_type_array_flush_elements(tmem); |
2628 | if (desc_array) | 2667 | eina_inarray_setup(tmem->array, desc->subtype->value_size, desc->step); |
2629 | eina_inarray_free(tmem->array); | ||
2630 | else | ||
2631 | eina_inarray_setup(tmem->array, desc->subtype->value_size, | ||
2632 | desc->step); | ||
2633 | } | 2668 | } |
2634 | else if (!desc_array) | 2669 | else |
2635 | { | 2670 | { |
2636 | tmem->array = eina_inarray_new(desc->subtype->value_size, desc->step); | 2671 | tmem->array = eina_inarray_new(desc->subtype->value_size, desc->step); |
2637 | if (!tmem->array) | 2672 | if (!tmem->array) |
2638 | return EINA_FALSE; | 2673 | return EINA_FALSE; |
2639 | } | 2674 | } |
2640 | 2675 | ||
2641 | if (desc_array) | ||
2642 | tmem->array = desc_array; | ||
2643 | |||
2644 | tmem->subtype = desc->subtype; | 2676 | tmem->subtype = desc->subtype; |
2645 | |||
2646 | return EINA_TRUE; | 2677 | return EINA_TRUE; |
2647 | } | 2678 | } |
2648 | 2679 | ||
@@ -2821,13 +2852,13 @@ _eina_value_type_list_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
2821 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | 2852 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) |
2822 | { | 2853 | { |
2823 | Eina_Strbuf *str = eina_strbuf_new(); | 2854 | Eina_Strbuf *str = eina_strbuf_new(); |
2855 | const char *s; | ||
2824 | if (!tmem->list) eina_strbuf_append(str, "[]"); | 2856 | if (!tmem->list) eina_strbuf_append(str, "[]"); |
2825 | else | 2857 | else |
2826 | { | 2858 | { |
2827 | const Eina_Value_Type *subtype = tmem->subtype; | 2859 | const Eina_Value_Type *subtype = tmem->subtype; |
2828 | const Eina_List *node; | 2860 | const Eina_List *node; |
2829 | Eina_Value tmp; | 2861 | Eina_Value tmp; |
2830 | const char *s; | ||
2831 | Eina_Bool first = EINA_TRUE; | 2862 | Eina_Bool first = EINA_TRUE; |
2832 | 2863 | ||
2833 | eina_value_setup(&tmp, EINA_VALUE_TYPE_STRING); | 2864 | eina_value_setup(&tmp, EINA_VALUE_TYPE_STRING); |
@@ -2867,10 +2898,10 @@ _eina_value_type_list_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
2867 | } | 2898 | } |
2868 | 2899 | ||
2869 | eina_strbuf_append_char(str, ']'); | 2900 | eina_strbuf_append_char(str, ']'); |
2870 | s = eina_strbuf_string_get(str); | ||
2871 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
2872 | eina_strbuf_free(str); | ||
2873 | } | 2901 | } |
2902 | s = eina_strbuf_string_get(str); | ||
2903 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
2904 | eina_strbuf_free(str); | ||
2874 | } | 2905 | } |
2875 | else if ((tmem->list) && (tmem->list->next == NULL)) | 2906 | else if ((tmem->list) && (tmem->list->next == NULL)) |
2876 | { | 2907 | { |
@@ -2932,18 +2963,36 @@ _eina_value_type_list_convert_from(const Eina_Value_Type *type, const Eina_Value | |||
2932 | } | 2963 | } |
2933 | 2964 | ||
2934 | static Eina_Bool | 2965 | static Eina_Bool |
2935 | _eina_value_type_list_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | 2966 | _eina_value_type_list_pset(const Eina_Value_Type *type, void *mem, const void *ptr) |
2936 | { | 2967 | { |
2937 | Eina_Value_List *tmem = mem; | 2968 | Eina_Value_List *tmem = mem; |
2938 | const Eina_Value_List *desc = ptr; | 2969 | const Eina_Value_List *desc = ptr; |
2939 | 2970 | ||
2971 | eina_error_set(0); | ||
2940 | if ((!tmem->subtype) && (!desc->subtype)) | 2972 | if ((!tmem->subtype) && (!desc->subtype)) |
2941 | return EINA_TRUE; | 2973 | return EINA_TRUE; |
2942 | 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 | |||
2943 | _eina_value_type_list_flush_elements(tmem); | 2993 | _eina_value_type_list_flush_elements(tmem); |
2944 | tmem->subtype = desc->subtype; | ||
2945 | tmem->list = desc->list; | ||
2946 | 2994 | ||
2995 | tmem->subtype = desc->subtype; | ||
2947 | return EINA_TRUE; | 2996 | return EINA_TRUE; |
2948 | } | 2997 | } |
2949 | 2998 | ||
@@ -2995,6 +3044,7 @@ _eina_value_type_hash_flush_each(const Eina_Hash *hash __UNUSED__, const void *k | |||
2995 | { | 3044 | { |
2996 | struct _eina_value_type_hash_flush_each_ctx *ctx = user_data; | 3045 | struct _eina_value_type_hash_flush_each_ctx *ctx = user_data; |
2997 | ctx->ret &= eina_value_type_flush(ctx->subtype, mem); | 3046 | ctx->ret &= eina_value_type_flush(ctx->subtype, mem); |
3047 | free(mem); | ||
2998 | return EINA_TRUE; | 3048 | return EINA_TRUE; |
2999 | } | 3049 | } |
3000 | 3050 | ||
@@ -3239,11 +3289,11 @@ _eina_value_type_hash_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
3239 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) | 3289 | (convert == EINA_VALUE_TYPE_STRINGSHARE)) |
3240 | { | 3290 | { |
3241 | Eina_Strbuf *str = eina_strbuf_new(); | 3291 | Eina_Strbuf *str = eina_strbuf_new(); |
3292 | const char *s; | ||
3242 | if (!tmem->hash) eina_strbuf_append(str, "{}"); | 3293 | if (!tmem->hash) eina_strbuf_append(str, "{}"); |
3243 | else | 3294 | else |
3244 | { | 3295 | { |
3245 | struct _eina_value_type_hash_convert_to_string_each_ctx ctx; | 3296 | struct _eina_value_type_hash_convert_to_string_each_ctx ctx; |
3246 | const char *s; | ||
3247 | 3297 | ||
3248 | ctx.subtype = tmem->subtype; | 3298 | ctx.subtype = tmem->subtype; |
3249 | ctx.str = str; | 3299 | ctx.str = str; |
@@ -3257,10 +3307,10 @@ _eina_value_type_hash_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
3257 | &ctx); | 3307 | &ctx); |
3258 | 3308 | ||
3259 | eina_strbuf_append_char(str, '}'); | 3309 | eina_strbuf_append_char(str, '}'); |
3260 | s = eina_strbuf_string_get(str); | ||
3261 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
3262 | eina_strbuf_free(str); | ||
3263 | } | 3310 | } |
3311 | s = eina_strbuf_string_get(str); | ||
3312 | ret = eina_value_type_pset(convert, convert_mem, &s); | ||
3313 | eina_strbuf_free(str); | ||
3264 | } | 3314 | } |
3265 | else if ((tmem->hash) && (eina_hash_population(tmem->hash) == 1)) | 3315 | else if ((tmem->hash) && (eina_hash_population(tmem->hash) == 1)) |
3266 | { | 3316 | { |
@@ -3288,22 +3338,38 @@ _eina_value_type_hash_convert_to(const Eina_Value_Type *type __UNUSED__, const E | |||
3288 | } | 3338 | } |
3289 | 3339 | ||
3290 | static Eina_Bool | 3340 | static Eina_Bool |
3291 | _eina_value_type_hash_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | 3341 | _eina_value_type_hash_pset(const Eina_Value_Type *type, void *mem, const void *ptr) |
3292 | { | 3342 | { |
3293 | Eina_Value_Hash *tmem = mem; | 3343 | Eina_Value_Hash *tmem = mem; |
3294 | const Eina_Value_Hash *desc = ptr; | 3344 | const Eina_Value_Hash *desc = ptr; |
3295 | 3345 | ||
3346 | eina_error_set(0); | ||
3296 | if ((!tmem->subtype) && (!desc->subtype)) | 3347 | if ((!tmem->subtype) && (!desc->subtype)) |
3297 | return EINA_TRUE; | 3348 | return EINA_TRUE; |
3298 | 3349 | ||
3299 | if (tmem->hash) _eina_value_type_hash_flush_elements(tmem); | 3350 | if ((tmem->hash) && (tmem->hash == desc->hash)) |
3351 | { | ||
3352 | tmem->subtype = desc->subtype; | ||
3353 | return EINA_TRUE; | ||
3354 | } | ||
3300 | 3355 | ||
3301 | if (desc->hash) | 3356 | if (desc->hash) |
3302 | tmem->hash = desc->hash; | 3357 | { |
3303 | else if (!_eina_value_type_hash_create(tmem)) | 3358 | Eina_Value_Hash tmp; |
3304 | return EINA_FALSE; | 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); | ||
3305 | 3369 | ||
3306 | tmem->subtype = desc->subtype; | 3370 | tmem->subtype = desc->subtype; |
3371 | if (!_eina_value_type_hash_create(tmem)) | ||
3372 | return EINA_FALSE; | ||
3307 | 3373 | ||
3308 | return EINA_TRUE; | 3374 | return EINA_TRUE; |
3309 | } | 3375 | } |
@@ -3424,7 +3490,7 @@ _eina_value_type_timeval_convert_to(const Eina_Value_Type *type __UNUSED__, cons | |||
3424 | return EINA_FALSE; | 3490 | return EINA_FALSE; |
3425 | return eina_value_type_pset(convert, convert_mem, &other_mem); | 3491 | return eina_value_type_pset(convert, convert_mem, &other_mem); |
3426 | } | 3492 | } |
3427 | else if (convert == EINA_VALUE_TYPE_ULONG) | 3493 | else if ((convert == EINA_VALUE_TYPE_ULONG) || (convert == EINA_VALUE_TYPE_TIMESTAMP)) |
3428 | { | 3494 | { |
3429 | unsigned long other_mem = v.tv_sec; | 3495 | unsigned long other_mem = v.tv_sec; |
3430 | if (EINA_UNLIKELY(v.tv_sec < 0)) | 3496 | if (EINA_UNLIKELY(v.tv_sec < 0)) |
@@ -3570,6 +3636,8 @@ _eina_value_type_blob_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | |||
3570 | Eina_Value_Blob *tmem = mem; | 3636 | Eina_Value_Blob *tmem = mem; |
3571 | if ((ops) && (ops->free)) | 3637 | if ((ops) && (ops->free)) |
3572 | ops->free(ops, (void *)tmem->memory, tmem->size); | 3638 | ops->free(ops, (void *)tmem->memory, tmem->size); |
3639 | tmem->memory = NULL; | ||
3640 | tmem->size = 0; | ||
3573 | return EINA_TRUE; | 3641 | return EINA_TRUE; |
3574 | } | 3642 | } |
3575 | 3643 | ||
@@ -3776,6 +3844,14 @@ _eina_value_type_blob_pset(const Eina_Value_Type *type __UNUSED__, void *mem, co | |||
3776 | Eina_Value_Blob *tmem = mem; | 3844 | Eina_Value_Blob *tmem = mem; |
3777 | const Eina_Value_Blob *desc = ptr; | 3845 | const Eina_Value_Blob *desc = ptr; |
3778 | 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 | |||
3779 | if ((ops) && (ops->free)) | 3855 | if ((ops) && (ops->free)) |
3780 | ops->free(ops, (void *)tmem->memory, tmem->size); | 3856 | ops->free(ops, (void *)tmem->memory, tmem->size); |
3781 | 3857 | ||
@@ -3872,6 +3948,7 @@ _eina_value_struct_operations_stringshare_find_member(const Eina_Value_Struct_Op | |||
3872 | return itr; | 3948 | return itr; |
3873 | } | 3949 | } |
3874 | 3950 | ||
3951 | itr = desc->members; | ||
3875 | name = eina_stringshare_add(name); | 3952 | name = eina_stringshare_add(name); |
3876 | eina_stringshare_del(name); /* we'll not use the contents, this is fine */ | 3953 | eina_stringshare_del(name); /* we'll not use the contents, this is fine */ |
3877 | /* stringshare and look again */ | 3954 | /* stringshare and look again */ |
@@ -3955,6 +4032,13 @@ _eina_value_type_struct_setup(const Eina_Value_Type *type __UNUSED__, void *mem) | |||
3955 | } | 4032 | } |
3956 | 4033 | ||
3957 | static Eina_Bool | 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 | ||
3958 | _eina_value_type_struct_flush_member(const Eina_Value_Struct_Member *member, Eina_Value_Struct *st) | 4042 | _eina_value_type_struct_flush_member(const Eina_Value_Struct_Member *member, Eina_Value_Struct *st) |
3959 | { | 4043 | { |
3960 | unsigned char *base = st->memory; | 4044 | unsigned char *base = st->memory; |
@@ -3969,6 +4053,9 @@ _eina_value_type_struct_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | |||
3969 | Eina_Value_Struct *tmem = mem; | 4053 | Eina_Value_Struct *tmem = mem; |
3970 | Eina_Bool ret = EINA_TRUE; | 4054 | Eina_Bool ret = EINA_TRUE; |
3971 | 4055 | ||
4056 | if ((!tmem->desc) || (!tmem->memory)) | ||
4057 | return EINA_TRUE; | ||
4058 | |||
3972 | itr = tmem->desc->members; | 4059 | itr = tmem->desc->members; |
3973 | if (tmem->desc->member_count > 0) | 4060 | if (tmem->desc->member_count > 0) |
3974 | { | 4061 | { |
@@ -3989,6 +4076,9 @@ _eina_value_type_struct_flush(const Eina_Value_Type *type __UNUSED__, void *mem) | |||
3989 | else | 4076 | else |
3990 | free(tmem->memory); | 4077 | free(tmem->memory); |
3991 | 4078 | ||
4079 | tmem->memory = NULL; | ||
4080 | tmem->desc = NULL; | ||
4081 | |||
3992 | return ret; | 4082 | return ret; |
3993 | } | 4083 | } |
3994 | 4084 | ||
@@ -4012,6 +4102,9 @@ _eina_value_type_struct_copy(const Eina_Value_Type *type __UNUSED__, const void | |||
4012 | 4102 | ||
4013 | *d = *s; | 4103 | *d = *s; |
4014 | 4104 | ||
4105 | if ((!s->desc) || (!s->memory)) | ||
4106 | return EINA_TRUE; | ||
4107 | |||
4015 | ops = _eina_value_type_struct_ops_get(src); | 4108 | ops = _eina_value_type_struct_ops_get(src); |
4016 | if ((ops) && (ops->copy)) | 4109 | if ((ops) && (ops->copy)) |
4017 | { | 4110 | { |
@@ -4021,7 +4114,10 @@ _eina_value_type_struct_copy(const Eina_Value_Type *type __UNUSED__, const void | |||
4021 | return EINA_TRUE; | 4114 | return EINA_TRUE; |
4022 | } | 4115 | } |
4023 | 4116 | ||
4024 | d->memory = malloc(s->desc->size); | 4117 | if ((ops) && (ops->alloc)) |
4118 | d->memory = ops->alloc(ops, s->desc); | ||
4119 | else | ||
4120 | d->memory = malloc(s->desc->size); | ||
4025 | if (!d->memory) | 4121 | if (!d->memory) |
4026 | { | 4122 | { |
4027 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | 4123 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); |
@@ -4043,14 +4139,17 @@ _eina_value_type_struct_copy(const Eina_Value_Type *type __UNUSED__, const void | |||
4043 | goto error; | 4139 | goto error; |
4044 | } | 4140 | } |
4045 | 4141 | ||
4046 | |||
4047 | return EINA_TRUE; | 4142 | return EINA_TRUE; |
4048 | 4143 | ||
4049 | error: | 4144 | error: |
4050 | itr--; | 4145 | itr--; |
4051 | for (; itr >= s->desc->members; itr--) | 4146 | for (; itr >= s->desc->members; itr--) |
4052 | _eina_value_type_struct_flush_member(itr, d); | 4147 | _eina_value_type_struct_flush_member(itr, d); |
4053 | free(d->memory); | 4148 | |
4149 | if ((ops) && (ops->free)) | ||
4150 | ops->free(ops, s->desc, d->memory); | ||
4151 | else | ||
4152 | free(d->memory); | ||
4054 | return EINA_FALSE; | 4153 | return EINA_FALSE; |
4055 | } | 4154 | } |
4056 | 4155 | ||
@@ -4072,7 +4171,9 @@ _eina_value_type_struct_compare(const Eina_Value_Type *type __UNUSED__, const vo | |||
4072 | const Eina_Value_Struct_Member *itr; | 4171 | const Eina_Value_Struct_Member *itr; |
4073 | int cmp = 0; | 4172 | int cmp = 0; |
4074 | 4173 | ||
4075 | if (ta->desc != tb->desc) | 4174 | if ((!ta->desc) && (!tb->desc)) |
4175 | return 0; | ||
4176 | else if (ta->desc != tb->desc) | ||
4076 | { | 4177 | { |
4077 | eina_error_set(EINA_ERROR_VALUE_FAILED); | 4178 | eina_error_set(EINA_ERROR_VALUE_FAILED); |
4078 | return -1; | 4179 | return -1; |
@@ -4236,11 +4337,12 @@ _eina_value_type_struct_desc_check(const Eina_Value_Struct_Desc *desc) | |||
4236 | } | 4337 | } |
4237 | 4338 | ||
4238 | static Eina_Bool | 4339 | static Eina_Bool |
4239 | _eina_value_type_struct_pset(const Eina_Value_Type *type __UNUSED__, void *mem, const void *ptr) | 4340 | _eina_value_type_struct_pset(const Eina_Value_Type *type, void *mem, const void *ptr) |
4240 | { | 4341 | { |
4241 | const Eina_Value_Struct_Operations *ops = _eina_value_type_struct_ops_get(mem); | 4342 | const Eina_Value_Struct_Operations *ops; |
4242 | Eina_Value_Struct *tmem = mem; | 4343 | Eina_Value_Struct *tmem = mem; |
4243 | const Eina_Value_Struct *desc = ptr; | 4344 | const Eina_Value_Struct *desc = ptr; |
4345 | const Eina_Value_Struct_Member *itr; | ||
4244 | 4346 | ||
4245 | if (!_eina_value_type_struct_desc_check(desc->desc)) | 4347 | if (!_eina_value_type_struct_desc_check(desc->desc)) |
4246 | { | 4348 | { |
@@ -4248,30 +4350,71 @@ _eina_value_type_struct_pset(const Eina_Value_Type *type __UNUSED__, void *mem, | |||
4248 | return EINA_FALSE; | 4350 | return EINA_FALSE; |
4249 | } | 4351 | } |
4250 | 4352 | ||
4251 | if ((ops) && (ops->free)) | 4353 | eina_error_set(0); |
4252 | ops->free(ops, tmem->desc, tmem->memory); | 4354 | if ((tmem->memory) && (tmem->memory == desc->memory)) |
4253 | else | 4355 | { |
4254 | free(tmem->memory); | 4356 | tmem->desc = desc->desc; |
4357 | return EINA_TRUE; | ||
4358 | } | ||
4255 | 4359 | ||
4256 | *tmem = *desc; | 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; | ||
4257 | 4375 | ||
4258 | ops = _eina_value_type_struct_ops_get(desc); | 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 | |||
4259 | if (!tmem->memory) | 4382 | if (!tmem->memory) |
4260 | { | 4383 | { |
4261 | if ((ops) && (ops->alloc)) | 4384 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); |
4262 | tmem->memory = ops->alloc(ops, tmem->desc); | 4385 | return EINA_FALSE; |
4263 | else | 4386 | } |
4264 | tmem->memory = malloc(tmem->desc->size); | ||
4265 | 4387 | ||
4266 | if (!tmem->memory) | 4388 | itr = tmem->desc->members; |
4267 | { | 4389 | if (tmem->desc->member_count > 0) |
4268 | eina_error_set(EINA_ERROR_OUT_OF_MEMORY); | 4390 | { |
4269 | return EINA_FALSE; | 4391 | const Eina_Value_Struct_Member *itr_end; |
4270 | } | 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; | ||
4271 | } | 4402 | } |
4272 | 4403 | ||
4273 | eina_error_set(0); | ||
4274 | return EINA_TRUE; | 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; | ||
4275 | } | 4418 | } |
4276 | 4419 | ||
4277 | static Eina_Bool | 4420 | static Eina_Bool |
@@ -4304,6 +4447,130 @@ static const Eina_Value_Type _EINA_VALUE_TYPE_STRUCT = { | |||
4304 | _eina_value_type_struct_pget | 4447 | _eina_value_type_struct_pget |
4305 | }; | 4448 | }; |
4306 | 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 | |||
4307 | /* keep all basic types inlined in an array so we can compare if it's | 4574 | /* keep all basic types inlined in an array so we can compare if it's |
4308 | * a basic type using pointer arithmetic. | 4575 | * a basic type using pointer arithmetic. |
4309 | * | 4576 | * |
@@ -4506,6 +4773,20 @@ static const Eina_Value_Type _EINA_VALUE_TYPE_BASICS[] = { | |||
4506 | _eina_value_type_string_vset, | 4773 | _eina_value_type_string_vset, |
4507 | _eina_value_type_string_pset, | 4774 | _eina_value_type_string_pset, |
4508 | _eina_value_type_string_common_pget | 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 | ||
4509 | } | 4790 | } |
4510 | }; | 4791 | }; |
4511 | 4792 | ||
@@ -4722,11 +5003,12 @@ eina_value_init(void) | |||
4722 | EINA_VALUE_TYPE_DOUBLE = _EINA_VALUE_TYPE_BASICS + 11; | 5003 | EINA_VALUE_TYPE_DOUBLE = _EINA_VALUE_TYPE_BASICS + 11; |
4723 | EINA_VALUE_TYPE_STRINGSHARE = _EINA_VALUE_TYPE_BASICS + 12; | 5004 | EINA_VALUE_TYPE_STRINGSHARE = _EINA_VALUE_TYPE_BASICS + 12; |
4724 | EINA_VALUE_TYPE_STRING = _EINA_VALUE_TYPE_BASICS + 13; | 5005 | EINA_VALUE_TYPE_STRING = _EINA_VALUE_TYPE_BASICS + 13; |
5006 | EINA_VALUE_TYPE_TIMESTAMP = _EINA_VALUE_TYPE_BASICS + 14; | ||
4725 | 5007 | ||
4726 | _EINA_VALUE_TYPE_BASICS_START = _EINA_VALUE_TYPE_BASICS + 0; | 5008 | _EINA_VALUE_TYPE_BASICS_START = _EINA_VALUE_TYPE_BASICS + 0; |
4727 | _EINA_VALUE_TYPE_BASICS_END = _EINA_VALUE_TYPE_BASICS + 13; | 5009 | _EINA_VALUE_TYPE_BASICS_END = _EINA_VALUE_TYPE_BASICS + 14; |
4728 | 5010 | ||
4729 | EINA_SAFETY_ON_FALSE_RETURN_VAL((sizeof(_EINA_VALUE_TYPE_BASICS)/sizeof(_EINA_VALUE_TYPE_BASICS[0])) == 14, EINA_FALSE); | 5011 | EINA_SAFETY_ON_FALSE_RETURN_VAL((sizeof(_EINA_VALUE_TYPE_BASICS)/sizeof(_EINA_VALUE_TYPE_BASICS[0])) == 15, EINA_FALSE); |
4730 | 5012 | ||
4731 | 5013 | ||
4732 | EINA_VALUE_TYPE_ARRAY = &_EINA_VALUE_TYPE_ARRAY; | 5014 | EINA_VALUE_TYPE_ARRAY = &_EINA_VALUE_TYPE_ARRAY; |
@@ -4735,6 +5017,7 @@ eina_value_init(void) | |||
4735 | EINA_VALUE_TYPE_TIMEVAL = &_EINA_VALUE_TYPE_TIMEVAL; | 5017 | EINA_VALUE_TYPE_TIMEVAL = &_EINA_VALUE_TYPE_TIMEVAL; |
4736 | EINA_VALUE_TYPE_BLOB = &_EINA_VALUE_TYPE_BLOB; | 5018 | EINA_VALUE_TYPE_BLOB = &_EINA_VALUE_TYPE_BLOB; |
4737 | EINA_VALUE_TYPE_STRUCT = &_EINA_VALUE_TYPE_STRUCT; | 5019 | EINA_VALUE_TYPE_STRUCT = &_EINA_VALUE_TYPE_STRUCT; |
5020 | EINA_VALUE_TYPE_MODEL = &_EINA_VALUE_TYPE_MODEL; | ||
4738 | 5021 | ||
4739 | EINA_VALUE_BLOB_OPERATIONS_MALLOC = &_EINA_VALUE_BLOB_OPERATIONS_MALLOC; | 5022 | EINA_VALUE_BLOB_OPERATIONS_MALLOC = &_EINA_VALUE_BLOB_OPERATIONS_MALLOC; |
4740 | 5023 | ||
@@ -4800,6 +5083,7 @@ EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UCHAR = NULL; | |||
4800 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_USHORT = NULL; | 5083 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_USHORT = NULL; |
4801 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UINT = NULL; | 5084 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UINT = NULL; |
4802 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_ULONG = NULL; | 5085 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_ULONG = NULL; |
5086 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_TIMESTAMP = NULL; | ||
4803 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UINT64 = NULL; | 5087 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_UINT64 = NULL; |
4804 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_CHAR = NULL; | 5088 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_CHAR = NULL; |
4805 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_SHORT = NULL; | 5089 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_SHORT = NULL; |
@@ -4816,6 +5100,7 @@ EAPI const Eina_Value_Type *EINA_VALUE_TYPE_HASH = NULL; | |||
4816 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_TIMEVAL = NULL; | 5100 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_TIMEVAL = NULL; |
4817 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_BLOB = NULL; | 5101 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_BLOB = NULL; |
4818 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_STRUCT = NULL; | 5102 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_STRUCT = NULL; |
5103 | EAPI const Eina_Value_Type *EINA_VALUE_TYPE_MODEL = NULL; | ||
4819 | 5104 | ||
4820 | EAPI const Eina_Value_Blob_Operations *EINA_VALUE_BLOB_OPERATIONS_MALLOC = NULL; | 5105 | EAPI const Eina_Value_Blob_Operations *EINA_VALUE_BLOB_OPERATIONS_MALLOC = NULL; |
4821 | 5106 | ||