projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
lib: make trace IR API const-correct
[babeltrace.git] / lib / trace-ir / fields.c
diff --git a/lib/trace-ir/fields.c b/lib/trace-ir/fields.c
index 376bc5d66c60d80ecbaa17738cd1122aa92a9121..519d65e55ebf3960dab29fe1fed73f978a9451c2 100644 (file)
--- a/lib/trace-ir/fields.c
+++ b/lib/trace-ir/fields.c
@@ -1,8 +1,4 @@
 /*
- * fields.c
- *
- * Babeltrace trace IR - Event Fields
- *
  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
  *
  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
@@ -31,10 +27,11 @@
 
 #include <babeltrace/assert-pre-internal.h>
 #include <babeltrace/trace-ir/fields.h>
+#include <babeltrace/trace-ir/fields-const.h>
 #include <babeltrace/trace-ir/fields-internal.h>
 #include <babeltrace/trace-ir/field-classes-internal.h>
 #include <babeltrace/object-internal.h>
-#include <babeltrace/ref.h>
+#include <babeltrace/object.h>
 #include <babeltrace/compiler-internal.h>
 #include <babeltrace/compat/fcntl-internal.h>
 #include <babeltrace/align-internal.h>
@@ -66,16 +63,16 @@ static
 void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen);
 
 static
-bool single_field_is_set(struct bt_field *field);
+bool single_field_is_set(const struct bt_field *field);
 
 static
-bool array_field_is_set(struct bt_field *field);
+bool array_field_is_set(const struct bt_field *field);
 
 static
-bool structure_field_is_set(struct bt_field *field);
+bool structure_field_is_set(const struct bt_field *field);
 
 static
-bool variant_field_is_set(struct bt_field *field);
+bool variant_field_is_set(const struct bt_field *field);
 
 static
 struct bt_field_methods integer_field_methods = {
@@ -142,16 +139,16 @@ struct bt_field *create_variant_field(struct bt_field_class *);
 
 static
 struct bt_field *(* const field_create_funcs[])(struct bt_field_class *) = {
-       [BT_FIELD_CLASS_ID_UNSIGNED_INTEGER]    = create_integer_field,
-       [BT_FIELD_CLASS_ID_SIGNED_INTEGER]      = create_integer_field,
-       [BT_FIELD_CLASS_ID_UNSIGNED_ENUMERATION] = create_integer_field,
-       [BT_FIELD_CLASS_ID_SIGNED_ENUMERATION]  = create_integer_field,
-       [BT_FIELD_CLASS_ID_REAL]                        = create_real_field,
-       [BT_FIELD_CLASS_ID_STRING]              = create_string_field,
-       [BT_FIELD_CLASS_ID_STRUCTURE]           = create_structure_field,
-       [BT_FIELD_CLASS_ID_STATIC_ARRAY]                = create_static_array_field,
-       [BT_FIELD_CLASS_ID_DYNAMIC_ARRAY]       = create_dynamic_array_field,
-       [BT_FIELD_CLASS_ID_VARIANT]             = create_variant_field,
+       [BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER]  = create_integer_field,
+       [BT_FIELD_CLASS_TYPE_SIGNED_INTEGER]    = create_integer_field,
+       [BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION] = create_integer_field,
+       [BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION]        = create_integer_field,
+       [BT_FIELD_CLASS_TYPE_REAL]                      = create_real_field,
+       [BT_FIELD_CLASS_TYPE_STRING]            = create_string_field,
+       [BT_FIELD_CLASS_TYPE_STRUCTURE]         = create_structure_field,
+       [BT_FIELD_CLASS_TYPE_STATIC_ARRAY]              = create_static_array_field,
+       [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY]     = create_dynamic_array_field,
+       [BT_FIELD_CLASS_TYPE_VARIANT]           = create_variant_field,
 };
 
 static
@@ -174,28 +171,35 @@ void destroy_variant_field(struct bt_field *field);
 
 static
 void (* const field_destroy_funcs[])(struct bt_field *) = {
-       [BT_FIELD_CLASS_ID_UNSIGNED_INTEGER]    = destroy_integer_field,
-       [BT_FIELD_CLASS_ID_SIGNED_INTEGER]      = destroy_integer_field,
-       [BT_FIELD_CLASS_ID_UNSIGNED_ENUMERATION] = destroy_integer_field,
-       [BT_FIELD_CLASS_ID_SIGNED_ENUMERATION]  = destroy_integer_field,
-       [BT_FIELD_CLASS_ID_REAL]                        = destroy_real_field,
-       [BT_FIELD_CLASS_ID_STRING]              = destroy_string_field,
-       [BT_FIELD_CLASS_ID_STRUCTURE]           = destroy_structure_field,
-       [BT_FIELD_CLASS_ID_STATIC_ARRAY]                = destroy_array_field,
-       [BT_FIELD_CLASS_ID_DYNAMIC_ARRAY]       = destroy_array_field,
-       [BT_FIELD_CLASS_ID_VARIANT]             = destroy_variant_field,
+       [BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER]  = destroy_integer_field,
+       [BT_FIELD_CLASS_TYPE_SIGNED_INTEGER]    = destroy_integer_field,
+       [BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION] = destroy_integer_field,
+       [BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION]        = destroy_integer_field,
+       [BT_FIELD_CLASS_TYPE_REAL]                      = destroy_real_field,
+       [BT_FIELD_CLASS_TYPE_STRING]            = destroy_string_field,
+       [BT_FIELD_CLASS_TYPE_STRUCTURE]         = destroy_structure_field,
+       [BT_FIELD_CLASS_TYPE_STATIC_ARRAY]              = destroy_array_field,
+       [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY]     = destroy_array_field,
+       [BT_FIELD_CLASS_TYPE_VARIANT]           = destroy_variant_field,
 };
 
-struct bt_field_class *bt_field_borrow_class(struct bt_field *field)
+struct bt_field_class *bt_field_borrow_class(const struct bt_field *field)
+{
+       BT_ASSERT_PRE_NON_NULL(field, "Field");
+       return field->class;
+}
+
+const struct bt_field_class *bt_field_borrow_class_const(
+               const struct bt_field *field)
 {
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        return field->class;
 }
 
-enum bt_field_class_id bt_field_get_class_id(struct bt_field *field)
+enum bt_field_class_type bt_field_get_class_type(const struct bt_field *field)
 {
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       return field->class->id;
+       return field->class->type;
 }
 
 BT_HIDDEN
@@ -204,8 +208,8 @@ struct bt_field *bt_field_create(struct bt_field_class *fc)
        struct bt_field *field = NULL;
 
        BT_ASSERT_PRE_NON_NULL(fc, "Field class");
-       BT_ASSERT(bt_field_class_has_known_id(fc));
-       field = field_create_funcs[fc->id](fc);
+       BT_ASSERT(bt_field_class_has_known_type(fc));
+       field = field_create_funcs[fc->type](fc);
        if (!field) {
                BT_LIB_LOGE("Cannot create field object from field classe: "
                        "%![fc-]+F", fc);
@@ -224,7 +228,8 @@ void init_field(struct bt_field *field, struct bt_field_class *fc,
        BT_ASSERT(fc);
        bt_object_init_unique(&field->base);
        field->methods = methods;
-       field->class = bt_get(fc);
+       field->class = fc;
+       bt_object_get_no_null_check(fc);
 }
 
 static
@@ -282,7 +287,7 @@ struct bt_field *create_string_field(struct bt_field_class *fc)
                sizeof(char), 1);
        if (!string_field->buf) {
                BT_LOGE_STR("Failed to allocate a GArray.");
-               BT_PUT(string_field);
+               BT_OBJECT_PUT_REF_AND_RESET(string_field);
                goto end;
        }
 
@@ -350,7 +355,7 @@ struct bt_field *create_structure_field(struct bt_field_class *fc)
                        &struct_field->fields)) {
                BT_LIB_LOGE("Cannot create structure member fields: "
                        "%![fc-]+F", fc);
-               BT_PUT(struct_field);
+               BT_OBJECT_PUT_REF_AND_RESET(struct_field);
                goto end;
        }
 
@@ -378,7 +383,7 @@ struct bt_field *create_variant_field(struct bt_field_class *fc)
                        &var_field->fields)) {
                BT_LIB_LOGE("Cannot create variant member fields: "
                        "%![fc-]+F", fc);
-               BT_PUT(var_field);
+               BT_OBJECT_PUT_REF_AND_RESET(var_field);
                goto end;
        }
 
@@ -442,7 +447,7 @@ struct bt_field *create_static_array_field(struct bt_field_class *fc)
        if (init_array_field_fields(array_field)) {
                BT_LIB_LOGE("Cannot create static array fields: "
                        "%![fc-]+F", fc);
-               BT_PUT(array_field);
+               BT_OBJECT_PUT_REF_AND_RESET(array_field);
                goto end;
        }
 
@@ -469,7 +474,7 @@ struct bt_field *create_dynamic_array_field(struct bt_field_class *fc)
        if (init_array_field_fields(array_field)) {
                BT_LIB_LOGE("Cannot create dynamic array fields: "
                        "%![fc-]+F", fc);
-               BT_PUT(array_field);
+               BT_OBJECT_PUT_REF_AND_RESET(array_field);
                goto end;
        }
 
@@ -479,9 +484,9 @@ end:
        return (void *) array_field;
 }
 
-int64_t bt_field_signed_integer_get_value(struct bt_field *field)
+int64_t bt_field_signed_integer_get_value(const struct bt_field *field)
 {
-       struct bt_field_integer *int_field = (void *) field;
+       const struct bt_field_integer *int_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
@@ -504,9 +509,9 @@ void bt_field_signed_integer_set_value(struct bt_field *field, int64_t value)
        bt_field_set_single(field, true);
 }
 
-uint64_t bt_field_unsigned_integer_get_value(struct bt_field *field)
+uint64_t bt_field_unsigned_integer_get_value(const struct bt_field *field)
 {
-       struct bt_field_integer *int_field = (void *) field;
+       const struct bt_field_integer *int_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
@@ -514,8 +519,7 @@ uint64_t bt_field_unsigned_integer_get_value(struct bt_field *field)
        return int_field->value.u;
 }
 
-void bt_field_unsigned_integer_set_value(struct bt_field *field,
-               uint64_t value)
+void bt_field_unsigned_integer_set_value(struct bt_field *field, uint64_t value)
 {
        struct bt_field_integer *int_field = (void *) field;
 
@@ -530,13 +534,13 @@ void bt_field_unsigned_integer_set_value(struct bt_field *field,
        bt_field_set_single(field, true);
 }
 
-double bt_field_real_get_value(struct bt_field *field)
+double bt_field_real_get_value(const struct bt_field *field)
 {
-       struct bt_field_real *real_field = (void *) field;
+       const struct bt_field_real *real_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field, BT_FIELD_CLASS_ID_REAL, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_REAL, "Field");
        return real_field->value;
 }
 
@@ -545,7 +549,7 @@ void bt_field_real_set_value(struct bt_field *field, double value)
        struct bt_field_real *real_field = (void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field, BT_FIELD_CLASS_ID_REAL, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_REAL, "Field");
        BT_ASSERT_PRE_FIELD_HOT(field, "Field");
        BT_ASSERT_PRE(
                !((struct bt_field_class_real *) field->class)->is_single_precision ||
@@ -556,56 +560,58 @@ void bt_field_real_set_value(struct bt_field *field, double value)
        bt_field_set_single(field, true);
 }
 
-int bt_field_unsigned_enumeration_get_mapping_labels(struct bt_field *field,
+int bt_field_unsigned_enumeration_get_mapping_labels(
+               const struct bt_field *field,
                bt_field_class_enumeration_mapping_label_array *label_array,
                uint64_t *count)
 {
-       struct bt_field_integer *int_field = (void *) field;
+       const struct bt_field_integer *int_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_NON_NULL(label_array, "Label array (output)");
        BT_ASSERT_PRE_NON_NULL(label_array, "Count (output)");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_UNSIGNED_ENUMERATION, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION, "Field");
        return bt_field_class_unsigned_enumeration_get_mapping_labels_by_value(
                field->class, int_field->value.u, label_array, count);
 }
 
-int bt_field_signed_enumeration_get_mapping_labels(struct bt_field *field,
+int bt_field_signed_enumeration_get_mapping_labels(
+               const struct bt_field *field,
                bt_field_class_enumeration_mapping_label_array *label_array,
                uint64_t *count)
 {
-       struct bt_field_integer *int_field = (void *) field;
+       const struct bt_field_integer *int_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_NON_NULL(label_array, "Label array (output)");
        BT_ASSERT_PRE_NON_NULL(label_array, "Count (output)");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_SIGNED_ENUMERATION, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION, "Field");
        return bt_field_class_signed_enumeration_get_mapping_labels_by_value(
                field->class, int_field->value.i, label_array, count);
 }
 
-const char *bt_field_string_get_value(struct bt_field *field)
+const char *bt_field_string_get_value(const struct bt_field *field)
 {
-       struct bt_field_string *string_field = (void *) field;
+       const struct bt_field_string *string_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field, BT_FIELD_CLASS_ID_STRING,
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
                "Field");
        return (const char *) string_field->buf->data;
 }
 
-uint64_t bt_field_string_get_length(struct bt_field *field)
+uint64_t bt_field_string_get_length(const struct bt_field *field)
 {
-       struct bt_field_string *string_field = (void *) field;
+       const struct bt_field_string *string_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field, BT_FIELD_CLASS_ID_STRING,
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
                "Field");
        return string_field->length;
 }
@@ -615,7 +621,7 @@ int bt_field_string_set_value(struct bt_field *field, const char *value)
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_NON_NULL(value, "Value");
        BT_ASSERT_PRE_FIELD_HOT(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field, BT_FIELD_CLASS_ID_STRING,
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
                "Field");
        bt_field_string_clear(field);
        return bt_field_string_append_with_length(field, value,
@@ -624,8 +630,8 @@ int bt_field_string_set_value(struct bt_field *field, const char *value)
 
 int bt_field_string_append(struct bt_field *field, const char *value)
 {
-       return bt_field_string_append_with_length(field, value,
-               (uint64_t) strlen(value));
+       return bt_field_string_append_with_length(field,
+               value, (uint64_t) strlen(value));
 }
 
 int bt_field_string_append_with_length(struct bt_field *field,
@@ -638,8 +644,8 @@ int bt_field_string_append_with_length(struct bt_field *field,
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_NON_NULL(value, "Value");
        BT_ASSERT_PRE_FIELD_HOT(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_STRING, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_STRING, "Field");
 
        /* Make sure no null bytes are appended */
        BT_ASSERT_PRE(memchr(value, '\0', length) == NULL,
@@ -666,31 +672,30 @@ int bt_field_string_clear(struct bt_field *field)
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_HOT(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_STRING, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_STRING, "Field");
        string_field->length = 0;
        bt_field_set_single(field, true);
        return 0;
 }
 
-uint64_t bt_field_array_get_length(struct bt_field *field)
+uint64_t bt_field_array_get_length(const struct bt_field *field)
 {
-       struct bt_field_array *array_field = (void *) field;
+       const struct bt_field_array *array_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_FIELD_IS_ARRAY(field, "Field");
        return array_field->length;
 }
 
-int bt_field_dynamic_array_set_length(struct bt_field *field,
-               uint64_t length)
+int bt_field_dynamic_array_set_length(struct bt_field *field, uint64_t length)
 {
        int ret = 0;
        struct bt_field_array *array_field = (void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_DYNAMIC_ARRAY, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY, "Field");
        BT_ASSERT_PRE_FIELD_HOT(field, "Field");
 
        if (unlikely(length > array_field->fields->len)) {
@@ -726,7 +731,8 @@ end:
        return ret;
 }
 
-struct bt_field *bt_field_array_borrow_element_field_by_index(
+static inline
+struct bt_field *borrow_array_field_element_field_by_index(
                struct bt_field *field, uint64_t index)
 {
        struct bt_field_array *array_field = (void *) field;
@@ -737,19 +743,49 @@ struct bt_field *bt_field_array_borrow_element_field_by_index(
        return array_field->fields->pdata[index];
 }
 
-struct bt_field *bt_field_structure_borrow_member_field_by_index(
+struct bt_field *bt_field_array_borrow_element_field_by_index(
+               struct bt_field *field, uint64_t index)
+{
+       return borrow_array_field_element_field_by_index(field, index);
+}
+
+const struct bt_field *
+bt_field_array_borrow_element_field_by_index_const(
+               const struct bt_field *field, uint64_t index)
+{
+       return borrow_array_field_element_field_by_index((void *) field, index);
+}
+
+static inline
+struct bt_field *borrow_structure_field_member_field_by_index(
                struct bt_field *field, uint64_t index)
 {
        struct bt_field_structure *struct_field = (void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_STRUCTURE, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_STRUCTURE, "Field");
        BT_ASSERT_PRE_VALID_INDEX(index, struct_field->fields->len);
        return struct_field->fields->pdata[index];
 }
 
-struct bt_field *bt_field_structure_borrow_member_field_by_name(
+struct bt_field *bt_field_structure_borrow_member_field_by_index(
+               struct bt_field *field, uint64_t index)
+{
+       return borrow_structure_field_member_field_by_index(field,
+               index);
+}
+
+const struct bt_field *
+bt_field_structure_borrow_member_field_by_index_const(
+               const struct bt_field *field, uint64_t index)
+{
+       return borrow_structure_field_member_field_by_index(
+               (void *) field, index);
+}
+
+static inline
+struct bt_field *borrow_structure_field_member_field_by_name(
                struct bt_field *field, const char *name)
 {
        struct bt_field *ret_field = NULL;
@@ -760,8 +796,8 @@ struct bt_field *bt_field_structure_borrow_member_field_by_name(
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
        BT_ASSERT_PRE_NON_NULL(name, "Field name");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_STRUCTURE, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_STRUCTURE, "Field");
        struct_fc = (void *) field->class;
 
        if (!g_hash_table_lookup_extended(struct_fc->common.name_to_index, name,
@@ -776,27 +812,53 @@ end:
        return ret_field;
 }
 
-struct bt_field *bt_field_variant_borrow_selected_option_field(
+struct bt_field *bt_field_structure_borrow_member_field_by_name(
+               struct bt_field *field, const char *name)
+{
+       return borrow_structure_field_member_field_by_name(field, name);
+}
+
+const struct bt_field *bt_field_structure_borrow_member_field_by_name_const(
+               const struct bt_field *field, const char *name)
+{
+       return borrow_structure_field_member_field_by_name(
+               (void *) field, name);
+}
+
+static inline
+struct bt_field *borrow_variant_field_selected_option_field(
                struct bt_field *field)
 {
        struct bt_field_variant *var_field = (void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_VARIANT, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_VARIANT, "Field");
        BT_ASSERT_PRE(var_field->selected_field,
                "Variant field has no selected field: %!+f", field);
        return var_field->selected_field;
 }
 
-int bt_field_variant_select_option_field(struct bt_field *field,
-               uint64_t index)
+struct bt_field *bt_field_variant_borrow_selected_option_field(
+               struct bt_field *field)
+{
+       return borrow_variant_field_selected_option_field(field);
+}
+
+const struct bt_field *bt_field_variant_borrow_selected_option_field_const(
+               const struct bt_field *field)
+{
+       return borrow_variant_field_selected_option_field((void *) field);
+}
+
+int bt_field_variant_select_option_field(
+               struct bt_field *field, uint64_t index)
 {
        struct bt_field_variant *var_field = (void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_VARIANT, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_VARIANT, "Field");
        BT_ASSERT_PRE_FIELD_HOT(field, "Field");
        BT_ASSERT_PRE_VALID_INDEX(index, var_field->fields->len);
        var_field->selected_field = var_field->fields->pdata[index];
@@ -805,13 +867,13 @@ int bt_field_variant_select_option_field(struct bt_field *field,
 }
 
 uint64_t bt_field_variant_get_selected_option_field_index(
-               struct bt_field *field)
+               const struct bt_field *field)
 {
-       struct bt_field_variant *var_field = (void *) field;
+       const struct bt_field_variant *var_field = (const void *) field;
 
        BT_ASSERT_PRE_NON_NULL(field, "Field");
-       BT_ASSERT_PRE_FIELD_HAS_CLASS_ID(field,
-               BT_FIELD_CLASS_ID_VARIANT, "Field");
+       BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
+               BT_FIELD_CLASS_TYPE_VARIANT, "Field");
        BT_ASSERT_PRE(var_field->selected_field,
                "Variant field has no selected field: %!+f", field);
        return var_field->selected_index;
@@ -822,7 +884,7 @@ void bt_field_finalize(struct bt_field *field)
 {
        BT_ASSERT(field);
        BT_LOGD_STR("Putting field's class.");
-       bt_put(field->class);
+       BT_OBJECT_PUT_REF_AND_RESET(field->class);
 }
 
 static
@@ -854,6 +916,7 @@ void destroy_structure_field(struct bt_field *field)
 
        if (struct_field->fields) {
                g_ptr_array_free(struct_field->fields, TRUE);
+               struct_field->fields = NULL;
        }
 
        g_free(field);
@@ -870,6 +933,7 @@ void destroy_variant_field(struct bt_field *field)
 
        if (var_field->fields) {
                g_ptr_array_free(var_field->fields, TRUE);
+               var_field->fields = NULL;
        }
 
        g_free(field);
@@ -886,6 +950,7 @@ void destroy_array_field(struct bt_field *field)
 
        if (array_field->fields) {
                g_ptr_array_free(array_field->fields, TRUE);
+               array_field->fields = NULL;
        }
 
        g_free(field);
@@ -902,6 +967,7 @@ void destroy_string_field(struct bt_field *field)
 
        if (string_field->buf) {
                g_array_free(string_field->buf, TRUE);
+               string_field->buf = NULL;
        }
 
        g_free(field);
@@ -911,8 +977,8 @@ BT_HIDDEN
 void bt_field_destroy(struct bt_field *field)
 {
        BT_ASSERT(field);
-       BT_ASSERT(bt_field_class_has_known_id(field->class));
-       field_destroy_funcs[field->class->id](field);
+       BT_ASSERT(bt_field_class_has_known_type(field->class));
+       field_destroy_funcs[field->class->type](field);
 }
 
 static
@@ -1031,29 +1097,29 @@ void set_array_field_is_frozen(struct bt_field *field, bool is_frozen)
 }
 
 BT_HIDDEN
-void _bt_field_set_is_frozen(struct bt_field *field,
+void _bt_field_set_is_frozen(const struct bt_field *field,
                bool is_frozen)
 {
        BT_ASSERT(field);
        BT_LIB_LOGD("Setting field object's frozen state: %!+f, is-frozen=%d",
                field, is_frozen);
        BT_ASSERT(field->methods->set_is_frozen);
-       field->methods->set_is_frozen(field, is_frozen);
+       field->methods->set_is_frozen((void *) field, is_frozen);
 }
 
 static
-bool single_field_is_set(struct bt_field *field)
+bool single_field_is_set(const struct bt_field *field)
 {
        BT_ASSERT(field);
        return field->is_set;
 }
 
 static
-bool structure_field_is_set(struct bt_field *field)
+bool structure_field_is_set(const struct bt_field *field)
 {
        bool is_set = true;
        uint64_t i;
-       struct bt_field_structure *struct_field = (void *) field;
+       const struct bt_field_structure *struct_field = (const void *) field;
 
        BT_ASSERT(field);
 
@@ -1069,9 +1135,9 @@ end:
 }
 
 static
-bool variant_field_is_set(struct bt_field *field)
+bool variant_field_is_set(const struct bt_field *field)
 {
-       struct bt_field_variant *var_field = (void *) field;
+       const struct bt_field_variant *var_field = (const void *) field;
        bool is_set = false;
 
        BT_ASSERT(field);
@@ -1084,11 +1150,11 @@ bool variant_field_is_set(struct bt_field *field)
 }
 
 static
-bool array_field_is_set(struct bt_field *field)
+bool array_field_is_set(const struct bt_field *field)
 {
        bool is_set = true;
        uint64_t i;
-       struct bt_field_array *array_field = (void *) field;
+       const struct bt_field_array *array_field = (const void *) field;
 
        BT_ASSERT(field);
 
BabelTrace - Trace Format Babel Tower
This page took 0.03785 seconds and 4 git commands to generate.