2 * SPDX-License-Identifier: MIT
4 * Copyright (c) 2015-2018 Philippe Proulx <pproulx@efficios.com>
7 #define BT_LOG_TAG "LIB/VALUE"
8 #include "lib/logging.h"
14 #include <babeltrace2/babeltrace.h>
16 #include "compat/compiler.h"
17 #include "common/common.h"
18 #include "compat/glib.h"
19 #include "lib/assert-cond.h"
20 #include "lib/value.h"
21 #include "common/assert.h"
22 #include "func-status.h"
24 #define BT_ASSERT_PRE_DEV_VALUE_HOT_FROM_FUNC(_func, _value) \
25 BT_ASSERT_PRE_DEV_HOT_FROM_FUNC(_func, "value-object", \
26 ((struct bt_value *) (_value)), "Value object", \
29 #define BT_ASSERT_PRE_DEV_VALUE_HOT(_value) \
30 BT_ASSERT_PRE_DEV_VALUE_HOT_FROM_FUNC(__func__, (_value))
32 #define BT_VALUE_TO_BOOL(_base) ((struct bt_value_bool *) (_base))
33 #define BT_VALUE_TO_INTEGER(_base) ((struct bt_value_integer *) (_base))
34 #define BT_VALUE_TO_REAL(_base) ((struct bt_value_real *) (_base))
35 #define BT_VALUE_TO_STRING(_base) ((struct bt_value_string *) (_base))
36 #define BT_VALUE_TO_ARRAY(_base) ((struct bt_value_array *) (_base))
37 #define BT_VALUE_TO_MAP(_base) ((struct bt_value_map *) (_base))
40 void bt_value_null_instance_release_func(struct bt_object
*obj
)
42 BT_LOGW("Releasing the null value singleton: addr=%p", obj
);
46 struct bt_value bt_value_null_instance
= {
50 .release_func
= bt_value_null_instance_release_func
,
51 .spec_release_func
= NULL
,
52 .parent_is_owner_listener_func
= NULL
,
55 .type
= BT_VALUE_TYPE_NULL
,
60 struct bt_value
*const bt_value_null
= &bt_value_null_instance
;
63 void bt_value_destroy(struct bt_object
*obj
);
66 void bt_value_string_destroy(struct bt_value
*object
)
68 g_string_free(BT_VALUE_TO_STRING(object
)->gstr
, TRUE
);
69 BT_VALUE_TO_STRING(object
)->gstr
= NULL
;
73 void bt_value_array_destroy(struct bt_value
*object
)
76 * Pointer array's registered value destructor will take care
77 * of putting each contained object.
79 g_ptr_array_free(BT_VALUE_TO_ARRAY(object
)->garray
, TRUE
);
80 BT_VALUE_TO_ARRAY(object
)->garray
= NULL
;
84 void bt_value_map_destroy(struct bt_value
*object
)
87 * Hash table's registered value destructor will take care of
88 * putting each contained object. Keys are GQuarks and cannot
89 * be destroyed anyway.
91 g_hash_table_destroy(BT_VALUE_TO_MAP(object
)->ght
);
92 BT_VALUE_TO_MAP(object
)->ght
= NULL
;
96 void (* const destroy_funcs
[])(struct bt_value
*) = {
97 [BT_VALUE_TYPE_NULL
] = NULL
,
98 [BT_VALUE_TYPE_BOOL
] = NULL
,
99 [BT_VALUE_TYPE_UNSIGNED_INTEGER
] = NULL
,
100 [BT_VALUE_TYPE_SIGNED_INTEGER
] = NULL
,
101 [BT_VALUE_TYPE_REAL
] = NULL
,
102 [BT_VALUE_TYPE_STRING
] = bt_value_string_destroy
,
103 [BT_VALUE_TYPE_ARRAY
] = bt_value_array_destroy
,
104 [BT_VALUE_TYPE_MAP
] = bt_value_map_destroy
,
108 struct bt_value
*bt_value_null_copy(const struct bt_value
*null_obj
)
110 BT_ASSERT(null_obj
== bt_value_null
);
112 bt_object_get_ref_no_null_check(bt_value_null
);
113 return (void *) bt_value_null
;
117 struct bt_value
*bt_value_bool_copy(const struct bt_value
*bool_obj
)
119 return bt_value_bool_create_init(
120 BT_VALUE_TO_BOOL(bool_obj
)->value
);
124 struct bt_value
*bt_value_integer_create_init(enum bt_value_type type
,
128 struct bt_value
*bt_value_integer_copy(
129 const struct bt_value
*integer_obj
)
131 return bt_value_integer_create_init(integer_obj
->type
,
132 BT_VALUE_TO_INTEGER(integer_obj
)->value
.u
);
136 struct bt_value
*bt_value_real_copy(const struct bt_value
*real_obj
)
138 return bt_value_real_create_init(
139 BT_VALUE_TO_REAL(real_obj
)->value
);
143 struct bt_value
*bt_value_string_copy(const struct bt_value
*string_obj
)
145 return bt_value_string_create_init(
146 BT_VALUE_TO_STRING(string_obj
)->gstr
->str
);
150 struct bt_value
*bt_value_array_copy(const struct bt_value
*array_obj
)
154 struct bt_value
*copy_obj
;
155 struct bt_value_array
*typed_array_obj
;
157 BT_LOGD("Copying array value: addr=%p", array_obj
);
158 typed_array_obj
= BT_VALUE_TO_ARRAY(array_obj
);
159 copy_obj
= bt_value_array_create();
161 BT_LIB_LOGE_APPEND_CAUSE("Cannot create empty array value.");
165 for (i
= 0; i
< typed_array_obj
->garray
->len
; ++i
) {
166 struct bt_value
*element_obj_copy
= NULL
;
167 const struct bt_value
*element_obj
=
168 bt_value_array_borrow_element_by_index_const(
171 BT_LOGD("Copying array value's element: element-addr=%p, "
172 "index=%d", element_obj
, i
);
173 ret
= bt_value_copy(element_obj
, &element_obj_copy
);
175 BT_LIB_LOGE_APPEND_CAUSE(
176 "Cannot copy array value's element: "
177 "array-addr=%p, index=%d",
179 BT_OBJECT_PUT_REF_AND_RESET(copy_obj
);
183 BT_ASSERT(element_obj_copy
);
184 ret
= bt_value_array_append_element(copy_obj
,
185 (void *) element_obj_copy
);
186 BT_OBJECT_PUT_REF_AND_RESET(element_obj_copy
);
188 BT_LIB_LOGE_APPEND_CAUSE(
189 "Cannot append to array value: addr=%p",
191 BT_OBJECT_PUT_REF_AND_RESET(copy_obj
);
196 BT_LOGD("Copied array value: original-addr=%p, copy-addr=%p",
197 array_obj
, copy_obj
);
204 struct bt_value
*bt_value_map_copy(const struct bt_value
*map_obj
)
208 gpointer key
, element_obj
;
209 struct bt_value
*copy_obj
;
210 struct bt_value
*element_obj_copy
= NULL
;
211 struct bt_value_map
*typed_map_obj
;
213 BT_LOGD("Copying map value: addr=%p", map_obj
);
214 typed_map_obj
= BT_VALUE_TO_MAP(map_obj
);
215 copy_obj
= bt_value_map_create();
220 g_hash_table_iter_init(&iter
, typed_map_obj
->ght
);
222 while (g_hash_table_iter_next(&iter
, &key
, &element_obj
)) {
223 const char *key_str
= g_quark_to_string(GPOINTER_TO_UINT(key
));
226 BT_LOGD("Copying map value's element: element-addr=%p, "
227 "key=\"%s\"", element_obj
, key_str
);
228 ret
= bt_value_copy(element_obj
, &element_obj_copy
);
230 BT_LIB_LOGE_APPEND_CAUSE(
231 "Cannot copy map value's element: "
232 "map-addr=%p, key=\"%s\"",
234 BT_OBJECT_PUT_REF_AND_RESET(copy_obj
);
238 BT_ASSERT(element_obj_copy
);
239 ret
= bt_value_map_insert_entry(copy_obj
, key_str
,
240 (void *) element_obj_copy
);
241 BT_OBJECT_PUT_REF_AND_RESET(element_obj_copy
);
243 BT_LIB_LOGE_APPEND_CAUSE(
244 "Cannot insert into map value: addr=%p, key=\"%s\"",
246 BT_OBJECT_PUT_REF_AND_RESET(copy_obj
);
251 BT_LOGD("Copied map value: addr=%p", map_obj
);
258 struct bt_value
*(* const copy_funcs
[])(const struct bt_value
*) = {
259 [BT_VALUE_TYPE_NULL
] = bt_value_null_copy
,
260 [BT_VALUE_TYPE_BOOL
] = bt_value_bool_copy
,
261 [BT_VALUE_TYPE_UNSIGNED_INTEGER
] = bt_value_integer_copy
,
262 [BT_VALUE_TYPE_SIGNED_INTEGER
] = bt_value_integer_copy
,
263 [BT_VALUE_TYPE_REAL
] = bt_value_real_copy
,
264 [BT_VALUE_TYPE_STRING
] = bt_value_string_copy
,
265 [BT_VALUE_TYPE_ARRAY
] = bt_value_array_copy
,
266 [BT_VALUE_TYPE_MAP
] = bt_value_map_copy
,
270 bt_bool
bt_value_null_is_equal(const struct bt_value
*object_a
,
271 const struct bt_value
*object_b
)
274 * Always BT_TRUE since bt_value_is_equal() already checks if both
275 * object_a and object_b have the same type, and in the case of
276 * null value objects, they're always the same if it is so.
282 bt_bool
bt_value_bool_is_equal(const struct bt_value
*object_a
,
283 const struct bt_value
*object_b
)
285 if (BT_VALUE_TO_BOOL(object_a
)->value
!=
286 BT_VALUE_TO_BOOL(object_b
)->value
) {
287 BT_LOGT("Boolean value objects are different: "
288 "bool-a-val=%d, bool-b-val=%d",
289 BT_VALUE_TO_BOOL(object_a
)->value
,
290 BT_VALUE_TO_BOOL(object_b
)->value
);
298 bt_bool
bt_value_integer_is_equal(const struct bt_value
*object_a
,
299 const struct bt_value
*object_b
)
301 if (BT_VALUE_TO_INTEGER(object_a
)->value
.u
!=
302 BT_VALUE_TO_INTEGER(object_b
)->value
.u
) {
303 if (object_a
->type
== BT_VALUE_TYPE_UNSIGNED_INTEGER
) {
304 BT_LOGT("Unsigned integer value objects are different: "
305 "int-a-val=%" PRIu64
", int-b-val=%" PRIu64
,
306 BT_VALUE_TO_INTEGER(object_a
)->value
.u
,
307 BT_VALUE_TO_INTEGER(object_b
)->value
.u
);
309 BT_LOGT("Signed integer value objects are different: "
310 "int-a-val=%" PRId64
", int-b-val=%" PRId64
,
311 BT_VALUE_TO_INTEGER(object_a
)->value
.i
,
312 BT_VALUE_TO_INTEGER(object_b
)->value
.i
);
322 bt_bool
bt_value_real_is_equal(const struct bt_value
*object_a
,
323 const struct bt_value
*object_b
)
325 if (BT_VALUE_TO_REAL(object_a
)->value
!=
326 BT_VALUE_TO_REAL(object_b
)->value
) {
327 BT_LOGT("Real number value objects are different: "
328 "real-a-val=%f, real-b-val=%f",
329 BT_VALUE_TO_REAL(object_a
)->value
,
330 BT_VALUE_TO_REAL(object_b
)->value
);
338 bt_bool
bt_value_string_is_equal(const struct bt_value
*object_a
,
339 const struct bt_value
*object_b
)
341 if (strcmp(BT_VALUE_TO_STRING(object_a
)->gstr
->str
,
342 BT_VALUE_TO_STRING(object_b
)->gstr
->str
) != 0) {
343 BT_LOGT("String value objects are different: "
344 "string-a-val=\"%s\", string-b-val=\"%s\"",
345 BT_VALUE_TO_STRING(object_a
)->gstr
->str
,
346 BT_VALUE_TO_STRING(object_b
)->gstr
->str
);
354 bt_bool
bt_value_array_is_equal(const struct bt_value
*object_a
,
355 const struct bt_value
*object_b
)
358 bt_bool ret
= BT_TRUE
;
359 const struct bt_value_array
*array_obj_a
=
360 BT_VALUE_TO_ARRAY(object_a
);
362 if (bt_value_array_get_length(object_a
) !=
363 bt_value_array_get_length(object_b
)) {
364 BT_LOGT("Array values are different: size mismatch "
365 "value-a-addr=%p, value-b-addr=%p, "
366 "value-a-size=%" PRId64
", value-b-size=%" PRId64
,
368 bt_value_array_get_length(object_a
),
369 bt_value_array_get_length(object_b
));
374 for (i
= 0; i
< array_obj_a
->garray
->len
; ++i
) {
375 const struct bt_value
*element_obj_a
;
376 const struct bt_value
*element_obj_b
;
378 element_obj_a
= bt_value_array_borrow_element_by_index_const(
380 element_obj_b
= bt_value_array_borrow_element_by_index_const(
383 if (!bt_value_is_equal(element_obj_a
, element_obj_b
)) {
384 BT_LOGT("Array values's elements are different: "
385 "value-a-addr=%p, value-b-addr=%p, index=%d",
386 element_obj_a
, element_obj_b
, i
);
397 bt_bool
bt_value_map_is_equal(const struct bt_value
*object_a
,
398 const struct bt_value
*object_b
)
400 bt_bool ret
= BT_TRUE
;
402 gpointer key
, element_obj_a
;
403 const struct bt_value_map
*map_obj_a
= BT_VALUE_TO_MAP(object_a
);
405 if (bt_value_map_get_size(object_a
) !=
406 bt_value_map_get_size(object_b
)) {
407 BT_LOGT("Map values are different: size mismatch "
408 "value-a-addr=%p, value-b-addr=%p, "
409 "value-a-size=%" PRId64
", value-b-size=%" PRId64
,
411 bt_value_map_get_size(object_a
),
412 bt_value_map_get_size(object_b
));
417 g_hash_table_iter_init(&iter
, map_obj_a
->ght
);
419 while (g_hash_table_iter_next(&iter
, &key
, &element_obj_a
)) {
420 const struct bt_value
*element_obj_b
;
421 const char *key_str
= g_quark_to_string(GPOINTER_TO_UINT(key
));
423 element_obj_b
= bt_value_map_borrow_entry_value_const(object_b
,
426 if (!bt_value_is_equal(element_obj_a
, element_obj_b
)) {
427 BT_LOGT("Map values's elements are different: "
428 "value-a-addr=%p, value-b-addr=%p, key=\"%s\"",
429 element_obj_a
, element_obj_b
, key_str
);
440 bt_bool (* const is_equal_funcs
[])(const struct bt_value
*,
441 const struct bt_value
*) = {
442 [BT_VALUE_TYPE_NULL
] = bt_value_null_is_equal
,
443 [BT_VALUE_TYPE_BOOL
] = bt_value_bool_is_equal
,
444 [BT_VALUE_TYPE_UNSIGNED_INTEGER
] = bt_value_integer_is_equal
,
445 [BT_VALUE_TYPE_SIGNED_INTEGER
] = bt_value_integer_is_equal
,
446 [BT_VALUE_TYPE_REAL
] = bt_value_real_is_equal
,
447 [BT_VALUE_TYPE_STRING
] = bt_value_string_is_equal
,
448 [BT_VALUE_TYPE_ARRAY
] = bt_value_array_is_equal
,
449 [BT_VALUE_TYPE_MAP
] = bt_value_map_is_equal
,
453 void bt_value_null_freeze(struct bt_value
*object
)
458 void bt_value_generic_freeze(struct bt_value
*object
)
460 object
->frozen
= BT_TRUE
;
464 void bt_value_array_freeze(struct bt_value
*object
)
467 struct bt_value_array
*typed_array_obj
=
468 BT_VALUE_TO_ARRAY(object
);
470 for (i
= 0; i
< typed_array_obj
->garray
->len
; ++i
) {
471 bt_value_freeze(g_ptr_array_index(typed_array_obj
->garray
, i
));
474 bt_value_generic_freeze(object
);
478 void bt_value_map_freeze(struct bt_value
*object
)
481 gpointer key
, element_obj
;
482 const struct bt_value_map
*map_obj
= BT_VALUE_TO_MAP(object
);
484 g_hash_table_iter_init(&iter
, map_obj
->ght
);
486 while (g_hash_table_iter_next(&iter
, &key
, &element_obj
)) {
487 bt_value_freeze(element_obj
);
490 bt_value_generic_freeze(object
);
494 void (* const freeze_funcs
[])(struct bt_value
*) = {
495 [BT_VALUE_TYPE_NULL
] = bt_value_null_freeze
,
496 [BT_VALUE_TYPE_BOOL
] = bt_value_generic_freeze
,
497 [BT_VALUE_TYPE_UNSIGNED_INTEGER
] = bt_value_generic_freeze
,
498 [BT_VALUE_TYPE_SIGNED_INTEGER
] = bt_value_generic_freeze
,
499 [BT_VALUE_TYPE_REAL
] = bt_value_generic_freeze
,
500 [BT_VALUE_TYPE_STRING
] = bt_value_generic_freeze
,
501 [BT_VALUE_TYPE_ARRAY
] = bt_value_array_freeze
,
502 [BT_VALUE_TYPE_MAP
] = bt_value_map_freeze
,
506 void bt_value_destroy(struct bt_object
*obj
)
508 struct bt_value
*value
;
510 value
= container_of(obj
, struct bt_value
, base
);
511 BT_LOGD("Destroying value: addr=%p", value
);
513 if (bt_value_is_null(value
)) {
514 BT_LOGD_STR("Not destroying the null value singleton.");
518 if (destroy_funcs
[value
->type
]) {
519 destroy_funcs
[value
->type
](value
);
525 void _bt_value_freeze(const struct bt_value
*c_object
)
527 const struct bt_value
*object
= (void *) c_object
;
531 if (object
->frozen
) {
535 BT_LOGD("Freezing value: addr=%p", object
);
536 freeze_funcs
[object
->type
]((void *) object
);
543 enum bt_value_type
bt_value_get_type(const struct bt_value
*object
)
545 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(object
);
550 struct bt_value
bt_value_create_base(enum bt_value_type type
)
552 struct bt_value value
;
555 value
.frozen
= BT_FALSE
;
556 bt_object_init_shared(&value
.base
, bt_value_destroy
);
561 struct bt_value
*bt_value_bool_create_init(bt_bool val
)
563 struct bt_value_bool
*bool_obj
;
565 BT_ASSERT_PRE_NO_ERROR();
567 BT_LOGD("Creating boolean value object: val=%d", val
);
568 bool_obj
= g_new0(struct bt_value_bool
, 1);
570 BT_LIB_LOGE_APPEND_CAUSE(
571 "Failed to allocate one boolean value object.");
575 bool_obj
->base
= bt_value_create_base(BT_VALUE_TYPE_BOOL
);
576 bool_obj
->value
= val
;
577 BT_LOGD("Created boolean value object: addr=%p", bool_obj
);
580 return (void *) bool_obj
;
584 struct bt_value
*bt_value_bool_create(void)
586 BT_ASSERT_PRE_NO_ERROR();
588 return bt_value_bool_create_init(BT_FALSE
);
592 struct bt_value
*bt_value_integer_create_init(enum bt_value_type type
,
595 struct bt_value_integer
*integer_obj
;
597 BT_ASSERT(type
== BT_VALUE_TYPE_UNSIGNED_INTEGER
||
598 type
== BT_VALUE_TYPE_SIGNED_INTEGER
);
600 if (type
== BT_VALUE_TYPE_UNSIGNED_INTEGER
) {
601 BT_LOGD("Creating unsigned integer value object: val=%" PRIu64
,
604 BT_LOGD("Creating signed integer value object: val=%" PRId64
,
608 integer_obj
= g_new0(struct bt_value_integer
, 1);
610 BT_LIB_LOGE_APPEND_CAUSE(
611 "Failed to allocate one integer value object.");
615 integer_obj
->base
= bt_value_create_base(type
);
616 integer_obj
->value
.u
= uval
;
617 BT_LOGD("Created %ssigned integer value object: addr=%p",
618 type
== BT_VALUE_TYPE_UNSIGNED_INTEGER
? "un" : "",
622 return (void *) integer_obj
;
626 struct bt_value
*bt_value_integer_unsigned_create_init(uint64_t val
)
628 BT_ASSERT_PRE_NO_ERROR();
630 return bt_value_integer_create_init(BT_VALUE_TYPE_UNSIGNED_INTEGER
,
635 struct bt_value
*bt_value_integer_unsigned_create(void)
637 BT_ASSERT_PRE_NO_ERROR();
639 return bt_value_integer_unsigned_create_init(0);
643 struct bt_value
*bt_value_integer_signed_create_init(int64_t val
)
645 BT_ASSERT_PRE_NO_ERROR();
647 return bt_value_integer_create_init(BT_VALUE_TYPE_SIGNED_INTEGER
,
652 struct bt_value
*bt_value_integer_signed_create(void)
654 BT_ASSERT_PRE_NO_ERROR();
656 return bt_value_integer_signed_create_init(0);
660 struct bt_value
*bt_value_real_create_init(double val
)
662 struct bt_value_real
*real_obj
;
664 BT_ASSERT_PRE_NO_ERROR();
666 BT_LOGD("Creating real number value object: val=%f", val
);
667 real_obj
= g_new0(struct bt_value_real
, 1);
669 BT_LIB_LOGE_APPEND_CAUSE(
670 "Failed to allocate one real number value object.");
674 real_obj
->base
= bt_value_create_base(BT_VALUE_TYPE_REAL
);
675 real_obj
->value
= val
;
676 BT_LOGD("Created real number value object: addr=%p",
680 return (void *) real_obj
;
684 struct bt_value
*bt_value_real_create(void)
686 BT_ASSERT_PRE_NO_ERROR();
688 return bt_value_real_create_init(0.);
692 struct bt_value
*bt_value_string_create_init(const char *val
)
694 struct bt_value_string
*string_obj
= NULL
;
696 BT_ASSERT_PRE_NO_ERROR();
697 BT_ASSERT_PRE_NON_NULL("raw-value", val
, "Raw value");
699 BT_LOGD("Creating string value object: val-len=%zu", strlen(val
));
700 string_obj
= g_new0(struct bt_value_string
, 1);
702 BT_LIB_LOGE_APPEND_CAUSE(
703 "Failed to allocate one string object.");
707 string_obj
->base
= bt_value_create_base(BT_VALUE_TYPE_STRING
);
708 string_obj
->gstr
= g_string_new(val
);
709 if (!string_obj
->gstr
) {
710 BT_LIB_LOGE_APPEND_CAUSE(
711 "Failed to allocate a GString.");
717 BT_LOGD("Created string value object: addr=%p",
721 return (void *) string_obj
;
725 struct bt_value
*bt_value_string_create(void)
727 BT_ASSERT_PRE_NO_ERROR();
729 return bt_value_string_create_init("");
733 struct bt_value
*bt_value_array_create(void)
735 struct bt_value_array
*array_obj
;
737 BT_ASSERT_PRE_NO_ERROR();
739 BT_LOGD_STR("Creating empty array value object.");
740 array_obj
= g_new0(struct bt_value_array
, 1);
742 BT_LIB_LOGE_APPEND_CAUSE(
743 "Failed to allocate one array object.");
747 array_obj
->base
= bt_value_create_base(BT_VALUE_TYPE_ARRAY
);
748 array_obj
->garray
= bt_g_ptr_array_new_full(0,
749 (GDestroyNotify
) bt_object_put_ref
);
750 if (!array_obj
->garray
) {
751 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
757 BT_LOGD("Created array value object: addr=%p",
761 return (void *) array_obj
;
765 struct bt_value
*bt_value_map_create(void)
767 struct bt_value_map
*map_obj
;
769 BT_ASSERT_PRE_NO_ERROR();
771 BT_LOGD_STR("Creating empty map value object.");
772 map_obj
= g_new0(struct bt_value_map
, 1);
774 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one map object.");
778 map_obj
->base
= bt_value_create_base(BT_VALUE_TYPE_MAP
);
779 map_obj
->ght
= g_hash_table_new_full(g_direct_hash
, g_direct_equal
,
780 NULL
, (GDestroyNotify
) bt_object_put_ref
);
782 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GHashTable.");
788 BT_LOGD("Created map value object: addr=%p",
792 return (void *) map_obj
;
796 bt_bool
bt_value_bool_get(const struct bt_value
*bool_obj
)
798 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(bool_obj
);
799 BT_ASSERT_PRE_DEV_VALUE_IS_BOOL(bool_obj
);
800 return BT_VALUE_TO_BOOL(bool_obj
)->value
;
804 void bt_value_bool_set(struct bt_value
*bool_obj
, bt_bool val
)
806 BT_ASSERT_PRE_VALUE_NON_NULL(bool_obj
);
807 BT_ASSERT_PRE_VALUE_IS_BOOL(bool_obj
);
808 BT_VALUE_TO_BOOL(bool_obj
)->value
= val
;
809 BT_LOGT("Set boolean value's raw value: value-addr=%p, value=%d",
814 uint64_t bt_value_integer_unsigned_get(const struct bt_value
*integer_obj
)
816 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(integer_obj
);
817 BT_ASSERT_PRE_DEV_VALUE_IS_UNSIGNED_INT(integer_obj
);
818 return BT_VALUE_TO_INTEGER(integer_obj
)->value
.u
;
822 int64_t bt_value_integer_signed_get(const struct bt_value
*integer_obj
)
824 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(integer_obj
);
825 BT_ASSERT_PRE_DEV_VALUE_IS_SIGNED_INT(integer_obj
);
826 return BT_VALUE_TO_INTEGER(integer_obj
)->value
.i
;
830 void set_integer_value(struct bt_value
*integer_obj
,
831 enum bt_value_type expected_type
, uint64_t uval
,
832 const char *api_func
)
834 BT_ASSERT_PRE_DEV_VALUE_HOT_FROM_FUNC(api_func
, integer_obj
);
835 BT_VALUE_TO_INTEGER(integer_obj
)->value
.u
= uval
;
839 void bt_value_integer_unsigned_set(struct bt_value
*integer_obj
,
842 BT_ASSERT_PRE_VALUE_NON_NULL(integer_obj
);
843 BT_ASSERT_PRE_VALUE_IS_UNSIGNED_INT(integer_obj
);
844 set_integer_value(integer_obj
, BT_VALUE_TYPE_UNSIGNED_INTEGER
, val
,
846 BT_LOGT("Set unsigned integer value's raw value: "
847 "value-addr=%p, value=%" PRIu64
, integer_obj
, val
);
851 void bt_value_integer_signed_set(struct bt_value
*integer_obj
,
854 BT_ASSERT_PRE_VALUE_NON_NULL(integer_obj
);
855 BT_ASSERT_PRE_VALUE_IS_SIGNED_INT(integer_obj
);
856 set_integer_value(integer_obj
, BT_VALUE_TYPE_SIGNED_INTEGER
,
857 (uint64_t) val
, __func__
);
858 BT_LOGT("Set signed integer value's raw value: "
859 "value-addr=%p, value=%" PRId64
, integer_obj
, val
);
863 double bt_value_real_get(const struct bt_value
*real_obj
)
865 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(real_obj
);
866 BT_ASSERT_PRE_DEV_VALUE_IS_REAL(real_obj
);
867 return BT_VALUE_TO_REAL(real_obj
)->value
;
871 void bt_value_real_set(struct bt_value
*real_obj
, double val
)
873 BT_ASSERT_PRE_VALUE_NON_NULL(real_obj
);
874 BT_ASSERT_PRE_VALUE_IS_REAL(real_obj
);
875 BT_ASSERT_PRE_DEV_VALUE_HOT(real_obj
);
876 BT_VALUE_TO_REAL(real_obj
)->value
= val
;
877 BT_LOGT("Set real number value's raw value: value-addr=%p, value=%f",
882 const char *bt_value_string_get(const struct bt_value
*string_obj
)
884 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(string_obj
);
885 BT_ASSERT_PRE_DEV_VALUE_IS_STRING(string_obj
);
886 return BT_VALUE_TO_STRING(string_obj
)->gstr
->str
;
890 enum bt_value_string_set_status
bt_value_string_set(
891 struct bt_value
*string_obj
, const char *val
)
893 BT_ASSERT_PRE_NO_ERROR();
894 BT_ASSERT_PRE_VALUE_NON_NULL(string_obj
);
895 BT_ASSERT_PRE_VALUE_IS_STRING(string_obj
);
896 BT_ASSERT_PRE_DEV_VALUE_HOT(string_obj
);
897 g_string_assign(BT_VALUE_TO_STRING(string_obj
)->gstr
, val
);
898 BT_LOGT("Set string value's raw value: value-addr=%p, raw-value-addr=%p",
900 return BT_FUNC_STATUS_OK
;
904 uint64_t bt_value_array_get_length(const struct bt_value
*array_obj
)
906 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(array_obj
);
907 BT_ASSERT_PRE_DEV_VALUE_IS_ARRAY(array_obj
);
908 return (uint64_t) BT_VALUE_TO_ARRAY(array_obj
)->garray
->len
;
912 struct bt_value
*bt_value_array_borrow_element_by_index(
913 struct bt_value
*array_obj
, uint64_t index
)
915 struct bt_value_array
*typed_array_obj
=
916 BT_VALUE_TO_ARRAY(array_obj
);
918 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(array_obj
);
919 BT_ASSERT_PRE_DEV_VALUE_IS_ARRAY(array_obj
);
920 BT_ASSERT_PRE_DEV_VALID_INDEX(index
, typed_array_obj
->garray
->len
);
921 return g_ptr_array_index(typed_array_obj
->garray
, index
);
925 const struct bt_value
*bt_value_array_borrow_element_by_index_const(
926 const struct bt_value
*array_obj
,
929 return bt_value_array_borrow_element_by_index(
930 (void *) array_obj
, index
);
934 enum bt_value_array_append_element_status
append_array_element(
935 struct bt_value
*array_obj
,
936 struct bt_value
*element_obj
, const char *api_func
)
938 struct bt_value_array
*typed_array_obj
=
939 BT_VALUE_TO_ARRAY(array_obj
);
941 BT_ASSERT_PRE_NO_ERROR_FROM_FUNC(api_func
);
942 BT_ASSERT_PRE_NON_NULL_FROM_FUNC(api_func
, "array-value-object",
943 array_obj
, "Array value object");
944 BT_ASSERT_PRE_NON_NULL_FROM_FUNC(api_func
, "element-value-object",
945 element_obj
, "Element value object");
946 BT_ASSERT_PRE_VALUE_HAS_TYPE_FROM_FUNC(api_func
, "value-object",
947 array_obj
, "array", BT_VALUE_TYPE_ARRAY
);
948 BT_ASSERT_PRE_DEV_VALUE_HOT_FROM_FUNC(api_func
, array_obj
);
949 g_ptr_array_add(typed_array_obj
->garray
, element_obj
);
950 bt_object_get_ref(element_obj
);
951 BT_LOGT("Appended element to array value: array-value-addr=%p, "
952 "element-value-addr=%p, new-size=%u",
953 array_obj
, element_obj
, typed_array_obj
->garray
->len
);
954 return BT_FUNC_STATUS_OK
;
958 enum bt_value_array_append_element_status
bt_value_array_append_element(
959 struct bt_value
*array_obj
,
960 struct bt_value
*element_obj
)
962 return append_array_element(array_obj
, element_obj
, __func__
);
966 enum bt_value_array_append_element_status
967 bt_value_array_append_bool_element(struct bt_value
*array_obj
, bt_bool val
)
969 enum bt_value_array_append_element_status ret
;
970 struct bt_value
*bool_obj
= NULL
;
972 BT_ASSERT_PRE_NO_ERROR();
974 bool_obj
= bt_value_bool_create_init(val
);
975 ret
= append_array_element(array_obj
,
976 (void *) bool_obj
, __func__
);
977 bt_object_put_ref(bool_obj
);
982 enum bt_value_array_append_element_status
983 bt_value_array_append_unsigned_integer_element(struct bt_value
*array_obj
,
986 enum bt_value_array_append_element_status ret
;
987 struct bt_value
*integer_obj
= NULL
;
989 BT_ASSERT_PRE_NO_ERROR();
991 integer_obj
= bt_value_integer_unsigned_create_init(val
);
992 ret
= append_array_element(array_obj
,
993 (void *) integer_obj
, __func__
);
994 bt_object_put_ref(integer_obj
);
999 enum bt_value_array_append_element_status
1000 bt_value_array_append_signed_integer_element(struct bt_value
*array_obj
,
1003 enum bt_value_array_append_element_status ret
;
1004 struct bt_value
*integer_obj
= NULL
;
1006 BT_ASSERT_PRE_NO_ERROR();
1008 integer_obj
= bt_value_integer_signed_create_init(val
);
1009 ret
= append_array_element(array_obj
,
1010 (void *) integer_obj
, __func__
);
1011 bt_object_put_ref(integer_obj
);
1016 enum bt_value_array_append_element_status
1017 bt_value_array_append_real_element(struct bt_value
*array_obj
, double val
)
1019 enum bt_value_array_append_element_status ret
;
1020 struct bt_value
*real_obj
= NULL
;
1022 BT_ASSERT_PRE_NO_ERROR();
1024 real_obj
= bt_value_real_create_init(val
);
1025 ret
= append_array_element(array_obj
,
1026 (void *) real_obj
, __func__
);
1027 bt_object_put_ref(real_obj
);
1032 enum bt_value_array_append_element_status
1033 bt_value_array_append_string_element(struct bt_value
*array_obj
,
1036 enum bt_value_array_append_element_status ret
;
1037 struct bt_value
*string_obj
= NULL
;
1039 BT_ASSERT_PRE_NO_ERROR();
1041 string_obj
= bt_value_string_create_init(val
);
1042 ret
= append_array_element(array_obj
,
1043 (void *) string_obj
, __func__
);
1044 bt_object_put_ref(string_obj
);
1049 enum bt_value_array_append_element_status
1050 bt_value_array_append_empty_array_element(struct bt_value
*array_obj
,
1051 struct bt_value
**element_obj
)
1053 enum bt_value_array_append_element_status ret
;
1054 struct bt_value
*empty_array_obj
= NULL
;
1056 BT_ASSERT_PRE_NO_ERROR();
1058 empty_array_obj
= bt_value_array_create();
1059 ret
= append_array_element(array_obj
,
1060 (void *) empty_array_obj
, __func__
);
1063 *element_obj
= empty_array_obj
;
1066 bt_object_put_ref(empty_array_obj
);
1071 enum bt_value_array_append_element_status
1072 bt_value_array_append_empty_map_element(struct bt_value
*array_obj
,
1073 struct bt_value
**element_obj
)
1075 enum bt_value_array_append_element_status ret
;
1076 struct bt_value
*map_obj
= NULL
;
1078 BT_ASSERT_PRE_NO_ERROR();
1080 map_obj
= bt_value_map_create();
1081 ret
= append_array_element(array_obj
,
1082 (void *) map_obj
, __func__
);
1085 *element_obj
= map_obj
;
1088 bt_object_put_ref(map_obj
);
1093 enum bt_value_array_set_element_by_index_status
1094 bt_value_array_set_element_by_index(struct bt_value
*array_obj
, uint64_t index
,
1095 struct bt_value
*element_obj
)
1097 struct bt_value_array
*typed_array_obj
=
1098 BT_VALUE_TO_ARRAY(array_obj
);
1100 BT_ASSERT_PRE_NO_ERROR();
1101 BT_ASSERT_PRE_NON_NULL("array-value-object", array_obj
,
1102 "Array value object");
1103 BT_ASSERT_PRE_NON_NULL("element-value-object", element_obj
,
1104 "Element value object");
1105 BT_ASSERT_PRE_VALUE_IS_ARRAY(array_obj
);
1106 BT_ASSERT_PRE_DEV_VALUE_HOT(array_obj
);
1107 BT_ASSERT_PRE_VALID_INDEX(index
, typed_array_obj
->garray
->len
);
1108 bt_object_put_ref(g_ptr_array_index(typed_array_obj
->garray
, index
));
1109 g_ptr_array_index(typed_array_obj
->garray
, index
) = element_obj
;
1110 bt_object_get_ref(element_obj
);
1111 BT_LOGT("Set array value's element: array-value-addr=%p, "
1112 "index=%" PRIu64
", element-value-addr=%p",
1113 array_obj
, index
, element_obj
);
1114 return BT_FUNC_STATUS_OK
;
1118 uint64_t bt_value_map_get_size(const struct bt_value
*map_obj
)
1120 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(map_obj
);
1121 BT_ASSERT_PRE_DEV_VALUE_IS_MAP(map_obj
);
1122 return (uint64_t) g_hash_table_size(BT_VALUE_TO_MAP(map_obj
)->ght
);
1126 struct bt_value
*bt_value_map_borrow_entry_value(struct bt_value
*map_obj
,
1129 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(map_obj
);
1130 BT_ASSERT_PRE_DEV_KEY_NON_NULL(key
);
1131 BT_ASSERT_PRE_DEV_VALUE_IS_MAP(map_obj
);
1132 return g_hash_table_lookup(BT_VALUE_TO_MAP(map_obj
)->ght
,
1133 GUINT_TO_POINTER(g_quark_from_string(key
)));
1137 const struct bt_value
*bt_value_map_borrow_entry_value_const(
1138 const struct bt_value
*map_obj
, const char *key
)
1140 return bt_value_map_borrow_entry_value((void *) map_obj
, key
);
1144 bt_bool
bt_value_map_has_entry(const struct bt_value
*map_obj
, const char *key
)
1146 BT_ASSERT_PRE_DEV_VALUE_NON_NULL(map_obj
);
1147 BT_ASSERT_PRE_DEV_KEY_NON_NULL(key
);
1148 BT_ASSERT_PRE_DEV_VALUE_IS_MAP(map_obj
);
1149 return bt_g_hash_table_contains(BT_VALUE_TO_MAP(map_obj
)->ght
,
1150 GUINT_TO_POINTER(g_quark_from_string(key
)));
1154 enum bt_value_map_insert_entry_status
insert_map_value_entry(
1155 struct bt_value
*map_obj
, const char *key
,
1156 struct bt_value
*element_obj
, const char *api_func
)
1158 BT_ASSERT_PRE_NO_ERROR_FROM_FUNC(api_func
);
1159 BT_ASSERT_PRE_NON_NULL_FROM_FUNC(api_func
, "map-value-object",
1160 map_obj
, "Map value object");
1161 BT_ASSERT_PRE_KEY_NON_NULL_FROM_FUNC(api_func
, key
);
1162 BT_ASSERT_PRE_NON_NULL_FROM_FUNC(api_func
,
1163 "element-value-object", element_obj
, "Element value object");
1164 BT_ASSERT_PRE_VALUE_HAS_TYPE_FROM_FUNC(api_func
, "value-object",
1165 map_obj
, "map", BT_VALUE_TYPE_MAP
);
1166 BT_ASSERT_PRE_DEV_VALUE_HOT_FROM_FUNC(api_func
, map_obj
);
1167 g_hash_table_insert(BT_VALUE_TO_MAP(map_obj
)->ght
,
1168 GUINT_TO_POINTER(g_quark_from_string(key
)), element_obj
);
1169 bt_object_get_ref(element_obj
);
1170 BT_LOGT("Inserted value into map value: map-value-addr=%p, "
1171 "key=\"%s\", element-value-addr=%p",
1172 map_obj
, key
, element_obj
);
1173 return BT_FUNC_STATUS_OK
;
1177 enum bt_value_map_insert_entry_status
bt_value_map_insert_entry(
1178 struct bt_value
*map_obj
, const char *key
,
1179 struct bt_value
*element_obj
)
1181 return insert_map_value_entry(map_obj
, key
, element_obj
, __func__
);
1185 enum bt_value_map_insert_entry_status
bt_value_map_insert_bool_entry(
1186 struct bt_value
*map_obj
, const char *key
, bt_bool val
)
1188 enum bt_value_map_insert_entry_status ret
;
1189 struct bt_value
*bool_obj
= NULL
;
1191 BT_ASSERT_PRE_NO_ERROR();
1193 bool_obj
= bt_value_bool_create_init(val
);
1194 ret
= insert_map_value_entry(map_obj
, key
,
1195 (void *) bool_obj
, __func__
);
1196 bt_object_put_ref(bool_obj
);
1201 enum bt_value_map_insert_entry_status
1202 bt_value_map_insert_unsigned_integer_entry(struct bt_value
*map_obj
,
1203 const char *key
, uint64_t val
)
1205 enum bt_value_map_insert_entry_status ret
;
1206 struct bt_value
*integer_obj
= NULL
;
1208 BT_ASSERT_PRE_NO_ERROR();
1210 integer_obj
= bt_value_integer_unsigned_create_init(val
);
1211 ret
= insert_map_value_entry(map_obj
, key
,
1212 (void *) integer_obj
, __func__
);
1213 bt_object_put_ref(integer_obj
);
1218 enum bt_value_map_insert_entry_status
1219 bt_value_map_insert_signed_integer_entry(struct bt_value
*map_obj
,
1220 const char *key
, int64_t val
)
1222 enum bt_value_map_insert_entry_status ret
;
1223 struct bt_value
*integer_obj
= NULL
;
1225 BT_ASSERT_PRE_NO_ERROR();
1227 integer_obj
= bt_value_integer_signed_create_init(val
);
1228 ret
= insert_map_value_entry(map_obj
, key
,
1229 (void *) integer_obj
, __func__
);
1230 bt_object_put_ref(integer_obj
);
1235 enum bt_value_map_insert_entry_status
bt_value_map_insert_real_entry(
1236 struct bt_value
*map_obj
, const char *key
, double val
)
1238 enum bt_value_map_insert_entry_status ret
;
1239 struct bt_value
*real_obj
= NULL
;
1241 BT_ASSERT_PRE_NO_ERROR();
1243 real_obj
= bt_value_real_create_init(val
);
1244 ret
= insert_map_value_entry(map_obj
, key
,
1245 (void *) real_obj
, __func__
);
1246 bt_object_put_ref(real_obj
);
1251 enum bt_value_map_insert_entry_status
bt_value_map_insert_string_entry(
1252 struct bt_value
*map_obj
, const char *key
,
1255 enum bt_value_map_insert_entry_status ret
;
1256 struct bt_value
*string_obj
= NULL
;
1258 BT_ASSERT_PRE_NO_ERROR();
1260 string_obj
= bt_value_string_create_init(val
);
1261 ret
= insert_map_value_entry(map_obj
, key
,
1262 (void *) string_obj
, __func__
);
1263 bt_object_put_ref(string_obj
);
1268 enum bt_value_map_insert_entry_status
1269 bt_value_map_insert_empty_array_entry(
1270 struct bt_value
*map_obj
, const char *key
,
1271 bt_value
**entry_obj
)
1273 enum bt_value_map_insert_entry_status ret
;
1274 struct bt_value
*array_obj
= NULL
;
1276 BT_ASSERT_PRE_NO_ERROR();
1278 array_obj
= bt_value_array_create();
1279 ret
= insert_map_value_entry(map_obj
, key
,
1280 (void *) array_obj
, __func__
);
1283 *entry_obj
= array_obj
;
1286 bt_object_put_ref(array_obj
);
1291 enum bt_value_map_insert_entry_status
1292 bt_value_map_insert_empty_map_entry(struct bt_value
*map_obj
, const char *key
,
1293 bt_value
**entry_obj
)
1295 enum bt_value_map_insert_entry_status ret
;
1296 struct bt_value
*empty_map_obj
= NULL
;
1298 BT_ASSERT_PRE_NO_ERROR();
1300 empty_map_obj
= bt_value_map_create();
1301 ret
= insert_map_value_entry(map_obj
, key
,
1302 (void *) empty_map_obj
, __func__
);
1305 *entry_obj
= empty_map_obj
;
1308 bt_object_put_ref(empty_map_obj
);
1313 enum bt_value_map_foreach_entry_status
foreach_map_entry(
1314 struct bt_value
*map_obj
, bt_value_map_foreach_entry_func func
,
1315 void *data
, const char *api_func
,
1316 const char *user_func_name
)
1318 int status
= BT_FUNC_STATUS_OK
;
1319 gpointer key
, element_obj
;
1320 GHashTableIter iter
;
1321 struct bt_value_map
*typed_map_obj
= BT_VALUE_TO_MAP(map_obj
);
1323 BT_ASSERT_PRE_NO_ERROR_FROM_FUNC(api_func
);
1324 BT_ASSERT_PRE_DEV_VALUE_NON_NULL_FROM_FUNC(api_func
, map_obj
);
1325 BT_ASSERT_PRE_DEV_NON_NULL_FROM_FUNC(api_func
, "user-function",
1326 func
, "User function");
1327 BT_ASSERT_PRE_VALUE_HAS_TYPE_FROM_FUNC(api_func
, "value-object",
1328 map_obj
, "map", BT_VALUE_TYPE_MAP
);
1329 g_hash_table_iter_init(&iter
, typed_map_obj
->ght
);
1331 while (g_hash_table_iter_next(&iter
, &key
, &element_obj
)) {
1332 const char *key_str
= g_quark_to_string(GPOINTER_TO_UINT(key
));
1334 status
= func(key_str
, element_obj
, data
);
1335 BT_ASSERT_POST_NO_ERROR_IF_NO_ERROR_STATUS(user_func_name
,
1337 if (status
!= BT_FUNC_STATUS_OK
) {
1339 BT_LIB_LOGE_APPEND_CAUSE(
1340 "User function failed while iterating "
1341 "map value entries: "
1342 "status=%s, key=\"%s\", "
1343 "value-addr=%p, data=%p",
1344 bt_common_func_status_string(status
),
1345 key_str
, element_obj
, data
);
1347 if (status
== BT_FUNC_STATUS_ERROR
) {
1349 * User function error becomes a
1350 * user error from this
1351 * function's caller's
1354 status
= BT_FUNC_STATUS_USER_ERROR
;
1357 BT_ASSERT(status
== BT_FUNC_STATUS_INTERRUPTED
);
1358 BT_LOGT("User interrupted the loop: status=%s, "
1359 "key=\"%s\", value-addr=%p, data=%p",
1360 bt_common_func_status_string(status
),
1361 key_str
, element_obj
, data
);
1372 enum bt_value_map_foreach_entry_status
bt_value_map_foreach_entry(
1373 struct bt_value
*map_obj
, bt_value_map_foreach_entry_func func
,
1376 return foreach_map_entry(map_obj
, func
, data
, __func__
,
1377 "bt_value_map_foreach_entry_func");
1381 enum bt_value_map_foreach_entry_const_status
bt_value_map_foreach_entry_const(
1382 const struct bt_value
*map_obj
,
1383 bt_value_map_foreach_entry_const_func func
, void *data
)
1385 return (int) foreach_map_entry((void *) map_obj
,
1386 (bt_value_map_foreach_entry_func
) func
, data
, __func__
,
1387 "bt_value_map_foreach_entry_const_func");
1390 struct extend_map_element_data
{
1391 struct bt_value
*base_obj
;
1395 bt_value_map_foreach_entry_const_func_status
extend_map_element(
1396 const char *key
, const struct bt_value
*extension_obj_elem
,
1400 struct extend_map_element_data
*extend_data
= data
;
1401 struct bt_value
*extension_obj_elem_copy
= NULL
;
1403 /* Copy object which is to replace the current one */
1404 status
= bt_value_copy(extension_obj_elem
, &extension_obj_elem_copy
);
1406 BT_LIB_LOGE_APPEND_CAUSE("Cannot copy map element: %!+v",
1407 extension_obj_elem
);
1411 BT_ASSERT(extension_obj_elem_copy
);
1413 /* Replace in base map value. */
1414 status
= bt_value_map_insert_entry(extend_data
->base_obj
, key
,
1415 extension_obj_elem_copy
);
1417 BT_LIB_LOGE_APPEND_CAUSE(
1418 "Cannot replace value in base map value: key=\"%s\", "
1419 "%![base-map-value-]+v, %![element-value-]+v",
1420 key
, extend_data
->base_obj
, extension_obj_elem_copy
);
1427 BT_ASSERT(status
< 0);
1430 BT_OBJECT_PUT_REF_AND_RESET(extension_obj_elem_copy
);
1431 BT_ASSERT(status
== BT_FUNC_STATUS_OK
||
1432 status
== BT_FUNC_STATUS_MEMORY_ERROR
);
1437 enum bt_value_map_extend_status
bt_value_map_extend(
1438 struct bt_value
*base_map_obj
,
1439 const struct bt_value
*extension_obj
)
1441 int status
= BT_FUNC_STATUS_OK
;
1442 struct extend_map_element_data extend_data
= {
1446 BT_ASSERT_PRE_NO_ERROR();
1447 BT_ASSERT_PRE_NON_NULL("base-value-object", base_map_obj
,
1448 "Base value object");
1449 BT_ASSERT_PRE_DEV_VALUE_HOT(base_map_obj
);
1450 BT_ASSERT_PRE_NON_NULL("extension-value-object", extension_obj
,
1451 "Extension value object");
1452 BT_ASSERT_PRE_VALUE_HAS_TYPE("base-value-object", base_map_obj
,
1453 "map", BT_VALUE_TYPE_MAP
);
1454 BT_ASSERT_PRE_VALUE_HAS_TYPE("extension-value-object", extension_obj
,
1455 "map", BT_VALUE_TYPE_MAP
);
1456 BT_LOGD("Extending map value: base-value-addr=%p, extension-value-addr=%p",
1457 base_map_obj
, extension_obj
);
1460 * For each key in the extension map object, replace this key
1461 * in the base map object.
1463 extend_data
.base_obj
= base_map_obj
;
1464 status
= bt_value_map_foreach_entry_const(extension_obj
,
1465 extend_map_element
, &extend_data
);
1466 if (status
!= BT_FUNC_STATUS_OK
) {
1467 BT_ASSERT(status
== BT_FUNC_STATUS_MEMORY_ERROR
);
1468 BT_LIB_LOGE_APPEND_CAUSE(
1469 "Cannot iterate on the extension object's elements: "
1470 "%![extension-value-]+v", extension_obj
);
1477 enum bt_value_copy_status
bt_value_copy(const struct bt_value
*object
,
1478 struct bt_value
**copy_obj
)
1480 enum bt_value_copy_status status
= BT_FUNC_STATUS_OK
;
1482 BT_ASSERT_PRE_NO_ERROR();
1483 BT_ASSERT_PRE_VALUE_NON_NULL(object
);
1484 BT_ASSERT_PRE_NON_NULL("value-object-copy-output", copy_obj
,
1485 "Value object copy (output)");
1486 BT_LOGD("Copying value object: addr=%p", object
);
1487 *copy_obj
= copy_funcs
[object
->type
](object
);
1489 BT_LOGD("Copied value object: copy-value-addr=%p",
1492 status
= BT_FUNC_STATUS_MEMORY_ERROR
;
1494 BT_LIB_LOGE_APPEND_CAUSE("Failed to copy value object.");
1501 bt_bool
bt_value_is_equal(const struct bt_value
*object_a
,
1502 const struct bt_value
*object_b
)
1504 bt_bool ret
= BT_FALSE
;
1506 BT_ASSERT_PRE_DEV_NON_NULL("value-object-a", object_a
,
1508 BT_ASSERT_PRE_DEV_NON_NULL("value-object-b", object_b
,
1511 if (object_a
->type
!= object_b
->type
) {
1512 BT_LOGT("Values are different: type mismatch: "
1513 "value-a-addr=%p, value-b-addr=%p, "
1514 "value-a-type=%s, value-b-type=%s",
1516 bt_common_value_type_string(object_a
->type
),
1517 bt_common_value_type_string(object_b
->type
));
1521 ret
= is_equal_funcs
[object_a
->type
](object_a
, object_b
);
1528 void bt_value_get_ref(const struct bt_value
*value
)
1530 bt_object_get_ref(value
);
1534 void bt_value_put_ref(const struct bt_value
*value
)
1536 bt_object_put_ref(value
);