projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
lib: rename `bt_object_{get,put}_no` -> `bt_object_{get,put}_ref_no`
[babeltrace.git] / src / lib / value.c
diff --git a/src/lib/value.c b/src/lib/value.c
index 0d42e8795ba22b8133c04ab0d72a3a6f29674f74..c8865ebc05c2d37eb451a3ccbb6bf1acdd920073 100644 (file)
--- a/src/lib/value.c
+++ b/src/lib/value.c
@@ -27,12 +27,11 @@
 #include <string.h>
 #include <string.h>
 #include <inttypes.h>
+#include <babeltrace2/babeltrace.h>
+
 #include "compat/compiler.h"
 #include "common/common.h"
-#include <babeltrace2/value-const.h>
-#include <babeltrace2/value.h>
 #include "compat/glib.h"
-#include <babeltrace2/types.h>
 #include "lib/assert-pre.h"
 #include "lib/value.h"
 #include "common/assert.h"
@@ -45,20 +44,27 @@
 #define BT_VALUE_TO_ARRAY(_base) ((struct bt_value_array *) (_base))
 #define BT_VALUE_TO_MAP(_base) ((struct bt_value_map *) (_base))
 
-#define BT_ASSERT_PRE_VALUE_IS_TYPE(_value, _type)                     \
-       BT_ASSERT_PRE(((struct bt_value *) (_value))->type == (_type),  \
-               "Value has the wrong type ID: expected-type=%s, "       \
-               "%![value-]+v", bt_common_value_type_string(_type),     \
-               (_value))
+#define _BT_ASSERT_PRE_VALUE_IS_TYPE_COND(_value, _type)               \
+       (((struct bt_value *) (_value))->type == (_type))
 
-#define BT_ASSERT_PRE_VALUE_HOT(_value, _name)                         \
-       BT_ASSERT_PRE_HOT(((struct bt_value *) (_value)), (_name),      \
-               ": %!+v", (_value))
+#define _BT_ASSERT_PRE_VALUE_IS_TYPE_FMT                               \
+       "Value has the wrong type ID: expected-type=%s, %![value-]+v"
 
-#define BT_ASSERT_PRE_VALUE_INDEX_IN_BOUNDS(_index, _count)            \
-       BT_ASSERT_PRE((_index) < (_count),                              \
-               "Index is out of bound: "                               \
-               "index=%" PRIu64 ", count=%u", (_index), (_count));
+#define BT_ASSERT_PRE_VALUE_IS_TYPE(_value, _type)                     \
+       BT_ASSERT_PRE(                                                  \
+               _BT_ASSERT_PRE_VALUE_IS_TYPE_COND((_value), (_type)),   \
+               _BT_ASSERT_PRE_VALUE_IS_TYPE_FMT,                       \
+               bt_common_value_type_string(_type), (_value))
+
+#define BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(_value, _type)                 \
+       BT_ASSERT_PRE_DEV(                                              \
+               _BT_ASSERT_PRE_VALUE_IS_TYPE_COND((_value), (_type)),   \
+               _BT_ASSERT_PRE_VALUE_IS_TYPE_FMT,                       \
+               bt_common_value_type_string(_type), (_value))
+
+#define BT_ASSERT_PRE_DEV_VALUE_HOT(_value, _name)                     \
+       BT_ASSERT_PRE_DEV_HOT(((struct bt_value *) (_value)), (_name),  \
+               ": %!+v", (_value))
 
 static
 void bt_value_null_instance_release_func(struct bt_object *obj)
@@ -130,6 +136,9 @@ void (* const destroy_funcs[])(struct bt_value *) = {
 static
 struct bt_value *bt_value_null_copy(const struct bt_value *null_obj)
 {
+       BT_ASSERT(null_obj == bt_value_null);
+
+       bt_object_get_ref_no_null_check(bt_value_null);
        return (void *) bt_value_null;
 }
 
@@ -380,14 +389,14 @@ bt_bool bt_value_array_compare(const struct bt_value *object_a,
        const struct bt_value_array *array_obj_a =
                BT_VALUE_TO_ARRAY(object_a);
 
-       if (bt_value_array_get_size(object_a) !=
-                       bt_value_array_get_size(object_b)) {
+       if (bt_value_array_get_length(object_a) !=
+                       bt_value_array_get_length(object_b)) {
                BT_LOGT("Array values are different: size mismatch "
                        "value-a-addr=%p, value-b-addr=%p, "
                        "value-a-size=%" PRId64 ", value-b-size=%" PRId64,
                        object_a, object_b,
-                       bt_value_array_get_size(object_a),
-                       bt_value_array_get_size(object_b));
+                       bt_value_array_get_length(object_a),
+                       bt_value_array_get_length(object_b));
                ret = BT_FALSE;
                goto end;
        }
@@ -563,7 +572,7 @@ end:
 
 enum bt_value_type bt_value_get_type(const struct bt_value *object)
 {
-       BT_ASSERT_PRE_NON_NULL(object, "Value object");
+       BT_ASSERT_PRE_DEV_NON_NULL(object, "Value object");
        return object->type;
 }
 
@@ -637,26 +646,26 @@ end:
        return (void *) integer_obj;
 }
 
-struct bt_value *bt_value_unsigned_integer_create_init(uint64_t val)
+struct bt_value *bt_value_integer_unsigned_create_init(uint64_t val)
 {
        return bt_value_integer_create_init(BT_VALUE_TYPE_UNSIGNED_INTEGER,
                val);
 }
 
-struct bt_value *bt_value_unsigned_integer_create(void)
+struct bt_value *bt_value_integer_unsigned_create(void)
 {
-       return bt_value_unsigned_integer_create_init(0);
+       return bt_value_integer_unsigned_create_init(0);
 }
 
-struct bt_value *bt_value_signed_integer_create_init(int64_t val)
+struct bt_value *bt_value_integer_signed_create_init(int64_t val)
 {
        return bt_value_integer_create_init(BT_VALUE_TYPE_SIGNED_INTEGER,
                (uint64_t) val);
 }
 
-struct bt_value *bt_value_signed_integer_create(void)
+struct bt_value *bt_value_integer_signed_create(void)
 {
-       return bt_value_signed_integer_create_init(0);
+       return bt_value_integer_signed_create_init(0);
 }
 
 struct bt_value *bt_value_real_create_init(double val)
@@ -779,8 +788,8 @@ end:
 
 bt_bool bt_value_bool_get(const struct bt_value *bool_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(bool_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(bool_obj, BT_VALUE_TYPE_BOOL);
+       BT_ASSERT_PRE_DEV_NON_NULL(bool_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(bool_obj, BT_VALUE_TYPE_BOOL);
        return BT_VALUE_TO_BOOL(bool_obj)->value;
 }
 
@@ -788,24 +797,24 @@ void bt_value_bool_set(struct bt_value *bool_obj, bt_bool val)
 {
        BT_ASSERT_PRE_NON_NULL(bool_obj, "Value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(bool_obj, BT_VALUE_TYPE_BOOL);
-       BT_ASSERT_PRE_VALUE_HOT(bool_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_HOT(bool_obj, "Value object");
        BT_VALUE_TO_BOOL(bool_obj)->value = val;
        BT_LOGT("Set boolean value's raw value: value-addr=%p, value=%d",
                bool_obj, val);
 }
 
-uint64_t bt_value_unsigned_integer_get(const struct bt_value *integer_obj)
+uint64_t bt_value_integer_unsigned_get(const struct bt_value *integer_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(integer_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(integer_obj,
+       BT_ASSERT_PRE_DEV_NON_NULL(integer_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(integer_obj,
                BT_VALUE_TYPE_UNSIGNED_INTEGER);
        return BT_VALUE_TO_INTEGER(integer_obj)->value.u;
 }
 
-int64_t bt_value_signed_integer_get(const struct bt_value *integer_obj)
+int64_t bt_value_integer_signed_get(const struct bt_value *integer_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(integer_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(integer_obj,
+       BT_ASSERT_PRE_DEV_NON_NULL(integer_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(integer_obj,
                BT_VALUE_TYPE_SIGNED_INTEGER);
        return BT_VALUE_TO_INTEGER(integer_obj)->value.i;
 }
@@ -816,11 +825,11 @@ void bt_value_integer_set(struct bt_value *integer_obj,
 {
        BT_ASSERT_PRE_NON_NULL(integer_obj, "Value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(integer_obj, expected_type);
-       BT_ASSERT_PRE_VALUE_HOT(integer_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_HOT(integer_obj, "Value object");
        BT_VALUE_TO_INTEGER(integer_obj)->value.u = uval;
 }
 
-void bt_value_unsigned_integer_set(struct bt_value *integer_obj,
+void bt_value_integer_unsigned_set(struct bt_value *integer_obj,
                uint64_t val)
 {
        bt_value_integer_set(integer_obj, BT_VALUE_TYPE_UNSIGNED_INTEGER, val);
@@ -828,7 +837,7 @@ void bt_value_unsigned_integer_set(struct bt_value *integer_obj,
                "value-addr=%p, value=%" PRIu64, integer_obj, val);
 }
 
-void bt_value_signed_integer_set(struct bt_value *integer_obj,
+void bt_value_integer_signed_set(struct bt_value *integer_obj,
                int64_t val)
 {
        bt_value_integer_set(integer_obj, BT_VALUE_TYPE_SIGNED_INTEGER,
@@ -839,8 +848,8 @@ void bt_value_signed_integer_set(struct bt_value *integer_obj,
 
 double bt_value_real_get(const struct bt_value *real_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(real_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(real_obj, BT_VALUE_TYPE_REAL);
+       BT_ASSERT_PRE_DEV_NON_NULL(real_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(real_obj, BT_VALUE_TYPE_REAL);
        return BT_VALUE_TO_REAL(real_obj)->value;
 }
 
@@ -848,7 +857,7 @@ void bt_value_real_set(struct bt_value *real_obj, double val)
 {
        BT_ASSERT_PRE_NON_NULL(real_obj, "Value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(real_obj, BT_VALUE_TYPE_REAL);
-       BT_ASSERT_PRE_VALUE_HOT(real_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_HOT(real_obj, "Value object");
        BT_VALUE_TO_REAL(real_obj)->value = val;
        BT_LOGT("Set real number value's raw value: value-addr=%p, value=%f",
                real_obj, val);
@@ -856,8 +865,8 @@ void bt_value_real_set(struct bt_value *real_obj, double val)
 
 const char *bt_value_string_get(const struct bt_value *string_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(string_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(string_obj, BT_VALUE_TYPE_STRING);
+       BT_ASSERT_PRE_DEV_NON_NULL(string_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(string_obj, BT_VALUE_TYPE_STRING);
        return BT_VALUE_TO_STRING(string_obj)->gstr->str;
 }
 
@@ -866,17 +875,17 @@ enum bt_value_string_set_status bt_value_string_set(
 {
        BT_ASSERT_PRE_NON_NULL(string_obj, "Value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(string_obj, BT_VALUE_TYPE_STRING);
-       BT_ASSERT_PRE_VALUE_HOT(string_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_HOT(string_obj, "Value object");
        g_string_assign(BT_VALUE_TO_STRING(string_obj)->gstr, val);
        BT_LOGT("Set string value's raw value: value-addr=%p, raw-value-addr=%p",
                string_obj, val);
        return BT_FUNC_STATUS_OK;
 }
 
-uint64_t bt_value_array_get_size(const struct bt_value *array_obj)
+uint64_t bt_value_array_get_length(const struct bt_value *array_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(array_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
+       BT_ASSERT_PRE_DEV_NON_NULL(array_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
        return (uint64_t) BT_VALUE_TO_ARRAY(array_obj)->garray->len;
 }
 
@@ -886,10 +895,9 @@ struct bt_value *bt_value_array_borrow_element_by_index(
        struct bt_value_array *typed_array_obj =
                BT_VALUE_TO_ARRAY(array_obj);
 
-       BT_ASSERT_PRE_NON_NULL(array_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
-       BT_ASSERT_PRE_VALUE_INDEX_IN_BOUNDS(index,
-               typed_array_obj->garray->len);
+       BT_ASSERT_PRE_DEV_NON_NULL(array_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
+       BT_ASSERT_PRE_DEV_VALID_INDEX(index, typed_array_obj->garray->len);
        return g_ptr_array_index(typed_array_obj->garray, index);
 }
 
@@ -911,7 +919,7 @@ enum bt_value_array_append_element_status bt_value_array_append_element(
        BT_ASSERT_PRE_NON_NULL(array_obj, "Array value object");
        BT_ASSERT_PRE_NON_NULL(element_obj, "Element value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
-       BT_ASSERT_PRE_VALUE_HOT(array_obj, "Array value object");
+       BT_ASSERT_PRE_DEV_VALUE_HOT(array_obj, "Array value object");
        g_ptr_array_add(typed_array_obj->garray, element_obj);
        bt_object_get_ref(element_obj);
        BT_LOGT("Appended element to array value: array-value-addr=%p, "
@@ -940,7 +948,7 @@ bt_value_array_append_unsigned_integer_element(struct bt_value *array_obj,
        enum bt_value_array_append_element_status ret;
        struct bt_value *integer_obj = NULL;
 
-       integer_obj = bt_value_unsigned_integer_create_init(val);
+       integer_obj = bt_value_integer_unsigned_create_init(val);
        ret = bt_value_array_append_element(array_obj,
                (void *) integer_obj);
        bt_object_put_ref(integer_obj);
@@ -954,7 +962,7 @@ bt_value_array_append_signed_integer_element(struct bt_value *array_obj,
        enum bt_value_array_append_element_status ret;
        struct bt_value *integer_obj = NULL;
 
-       integer_obj = bt_value_signed_integer_create_init(val);
+       integer_obj = bt_value_integer_signed_create_init(val);
        ret = bt_value_array_append_element(array_obj,
                (void *) integer_obj);
        bt_object_put_ref(integer_obj);
@@ -989,7 +997,8 @@ bt_value_array_append_string_element(struct bt_value *array_obj,
 }
 
 enum bt_value_array_append_element_status
-bt_value_array_append_empty_array_element(struct bt_value *array_obj)
+bt_value_array_append_empty_array_element(struct bt_value *array_obj,
+               struct bt_value **element_obj)
 {
        enum bt_value_array_append_element_status ret;
        struct bt_value *empty_array_obj = NULL;
@@ -997,12 +1006,18 @@ bt_value_array_append_empty_array_element(struct bt_value *array_obj)
        empty_array_obj = bt_value_array_create();
        ret = bt_value_array_append_element(array_obj,
                (void *) empty_array_obj);
+
+       if (element_obj) {
+               *element_obj = empty_array_obj;
+       }
+
        bt_object_put_ref(empty_array_obj);
        return ret;
 }
 
 enum bt_value_array_append_element_status
-bt_value_array_append_empty_map_element(struct bt_value *array_obj)
+bt_value_array_append_empty_map_element(struct bt_value *array_obj,
+               struct bt_value **element_obj)
 {
        enum bt_value_array_append_element_status ret;
        struct bt_value *map_obj = NULL;
@@ -1010,6 +1025,11 @@ bt_value_array_append_empty_map_element(struct bt_value *array_obj)
        map_obj = bt_value_map_create();
        ret = bt_value_array_append_element(array_obj,
                (void *) map_obj);
+
+       if (element_obj) {
+               *element_obj = map_obj;
+       }
+
        bt_object_put_ref(map_obj);
        return ret;
 }
@@ -1024,9 +1044,8 @@ bt_value_array_set_element_by_index(struct bt_value *array_obj, uint64_t index,
        BT_ASSERT_PRE_NON_NULL(array_obj, "Array value object");
        BT_ASSERT_PRE_NON_NULL(element_obj, "Element value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
-       BT_ASSERT_PRE_VALUE_HOT(array_obj, "Array value object");
-       BT_ASSERT_PRE_VALUE_INDEX_IN_BOUNDS(index,
-               typed_array_obj->garray->len);
+       BT_ASSERT_PRE_DEV_VALUE_HOT(array_obj, "Array value object");
+       BT_ASSERT_PRE_VALID_INDEX(index, typed_array_obj->garray->len);
        bt_object_put_ref(g_ptr_array_index(typed_array_obj->garray, index));
        g_ptr_array_index(typed_array_obj->garray, index) = element_obj;
        bt_object_get_ref(element_obj);
@@ -1038,17 +1057,17 @@ bt_value_array_set_element_by_index(struct bt_value *array_obj, uint64_t index,
 
 uint64_t bt_value_map_get_size(const struct bt_value *map_obj)
 {
-       BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
+       BT_ASSERT_PRE_DEV_NON_NULL(map_obj, "Value object");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
        return (uint64_t) g_hash_table_size(BT_VALUE_TO_MAP(map_obj)->ght);
 }
 
 struct bt_value *bt_value_map_borrow_entry_value(struct bt_value *map_obj,
                const char *key)
 {
-       BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
-       BT_ASSERT_PRE_NON_NULL(key, "Key");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
+       BT_ASSERT_PRE_DEV_NON_NULL(map_obj, "Value object");
+       BT_ASSERT_PRE_DEV_NON_NULL(key, "Key");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
        return g_hash_table_lookup(BT_VALUE_TO_MAP(map_obj)->ght,
                GUINT_TO_POINTER(g_quark_from_string(key)));
 }
@@ -1061,9 +1080,9 @@ const struct bt_value *bt_value_map_borrow_entry_value_const(
 
 bt_bool bt_value_map_has_entry(const struct bt_value *map_obj, const char *key)
 {
-       BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
-       BT_ASSERT_PRE_NON_NULL(key, "Key");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
+       BT_ASSERT_PRE_DEV_NON_NULL(map_obj, "Value object");
+       BT_ASSERT_PRE_DEV_NON_NULL(key, "Key");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
        return bt_g_hash_table_contains(BT_VALUE_TO_MAP(map_obj)->ght,
                GUINT_TO_POINTER(g_quark_from_string(key)));
 }
@@ -1076,7 +1095,7 @@ enum bt_value_map_insert_entry_status bt_value_map_insert_entry(
        BT_ASSERT_PRE_NON_NULL(key, "Key");
        BT_ASSERT_PRE_NON_NULL(element_obj, "Element value object");
        BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
-       BT_ASSERT_PRE_VALUE_HOT(map_obj, "Map value object");
+       BT_ASSERT_PRE_DEV_VALUE_HOT(map_obj, "Map value object");
        g_hash_table_insert(BT_VALUE_TO_MAP(map_obj)->ght,
                GUINT_TO_POINTER(g_quark_from_string(key)), element_obj);
        bt_object_get_ref(element_obj);
@@ -1106,7 +1125,7 @@ bt_value_map_insert_unsigned_integer_entry(struct bt_value *map_obj,
        enum bt_value_map_insert_entry_status ret;
        struct bt_value *integer_obj = NULL;
 
-       integer_obj = bt_value_unsigned_integer_create_init(val);
+       integer_obj = bt_value_integer_unsigned_create_init(val);
        ret = bt_value_map_insert_entry(map_obj, key,
                (void *) integer_obj);
        bt_object_put_ref(integer_obj);
@@ -1120,7 +1139,7 @@ bt_value_map_insert_signed_integer_entry(struct bt_value *map_obj,
        enum bt_value_map_insert_entry_status ret;
        struct bt_value *integer_obj = NULL;
 
-       integer_obj = bt_value_signed_integer_create_init(val);
+       integer_obj = bt_value_integer_signed_create_init(val);
        ret = bt_value_map_insert_entry(map_obj, key,
                (void *) integer_obj);
        bt_object_put_ref(integer_obj);
@@ -1156,7 +1175,8 @@ enum bt_value_map_insert_entry_status bt_value_map_insert_string_entry(
 
 enum bt_value_map_insert_entry_status
 bt_value_map_insert_empty_array_entry(
-               struct bt_value *map_obj, const char *key)
+               struct bt_value *map_obj, const char *key,
+               bt_value **entry_obj)
 {
        enum bt_value_map_insert_entry_status ret;
        struct bt_value *array_obj = NULL;
@@ -1164,12 +1184,18 @@ bt_value_map_insert_empty_array_entry(
        array_obj = bt_value_array_create();
        ret = bt_value_map_insert_entry(map_obj, key,
                (void *) array_obj);
+
+       if (entry_obj) {
+               *entry_obj = array_obj;
+       }
+
        bt_object_put_ref(array_obj);
        return ret;
 }
 
 enum bt_value_map_insert_entry_status
-bt_value_map_insert_empty_map_entry(struct bt_value *map_obj, const char *key)
+bt_value_map_insert_empty_map_entry(struct bt_value *map_obj, const char *key,
+               bt_value **entry_obj)
 {
        enum bt_value_map_insert_entry_status ret;
        struct bt_value *empty_map_obj = NULL;
@@ -1177,6 +1203,11 @@ bt_value_map_insert_empty_map_entry(struct bt_value *map_obj, const char *key)
        empty_map_obj = bt_value_map_create();
        ret = bt_value_map_insert_entry(map_obj, key,
                (void *) empty_map_obj);
+
+       if (entry_obj) {
+               *entry_obj = empty_map_obj;
+       }
+
        bt_object_put_ref(empty_map_obj);
        return ret;
 }
@@ -1190,19 +1221,19 @@ enum bt_value_map_foreach_entry_status bt_value_map_foreach_entry(
        GHashTableIter iter;
        struct bt_value_map *typed_map_obj = BT_VALUE_TO_MAP(map_obj);
 
-       BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
-       BT_ASSERT_PRE_NON_NULL(func, "Callback");
-       BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
+       BT_ASSERT_PRE_DEV_NON_NULL(map_obj, "Value object");
+       BT_ASSERT_PRE_DEV_NON_NULL(func, "Callback");
+       BT_ASSERT_PRE_DEV_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
        g_hash_table_iter_init(&iter, typed_map_obj->ght);
 
        while (g_hash_table_iter_next(&iter, &key, &element_obj)) {
                const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
 
                if (!func(key_str, element_obj, data)) {
-                       BT_LOGT("User canceled the loop: key=\"%s\", "
+                       BT_LOGT("User interrupted the loop: key=\"%s\", "
                                "value-addr=%p, data=%p",
                                key_str, element_obj, data);
-                       ret = BT_FUNC_STATUS_CANCELED;
+                       ret = BT_FUNC_STATUS_INTERRUPTED;
                        break;
                }
        }
@@ -1356,8 +1387,8 @@ bt_bool bt_value_compare(const struct bt_value *object_a,
 {
        bt_bool ret = BT_FALSE;
 
-       BT_ASSERT_PRE_NON_NULL(object_a, "Value object A");
-       BT_ASSERT_PRE_NON_NULL(object_b, "Value object B");
+       BT_ASSERT_PRE_DEV_NON_NULL(object_a, "Value object A");
+       BT_ASSERT_PRE_DEV_NON_NULL(object_b, "Value object B");
 
        if (object_a->type != object_b->type) {
                BT_LOGT("Values are different: type mismatch: "
BabelTrace - Trace Format Babel Tower
This page took 0.03115 seconds and 4 git commands to generate.