X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Flib%2Ftrace-ir%2Ffield.c;h=ca7dbb20d64f32dd3635d40fba729b2c204b1d75;hb=de821fe507f035622c474f097b226f30cd3c7491;hp=3f10d6eea28274177c905ead24f0a9db81197a32;hpb=d24d56638469189904fb6ddbb3c725817b3e9417;p=babeltrace.git diff --git a/src/lib/trace-ir/field.c b/src/lib/trace-ir/field.c index 3f10d6ee..ca7dbb20 100644 --- a/src/lib/trace-ir/field.c +++ b/src/lib/trace-ir/field.c @@ -47,6 +47,9 @@ void reset_array_field(struct bt_field *field); static void reset_structure_field(struct bt_field *field); +static +void reset_option_field(struct bt_field *field); + static void reset_variant_field(struct bt_field *field); @@ -59,6 +62,9 @@ void set_array_field_is_frozen(struct bt_field *field, bool is_frozen); static void set_structure_field_is_frozen(struct bt_field *field, bool is_frozen); +static +void set_option_field_is_frozen(struct bt_field *field, bool is_frozen); + static void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen); @@ -71,9 +77,26 @@ bool array_field_is_set(const struct bt_field *field); static bool structure_field_is_set(const struct bt_field *field); +static +bool option_field_is_set(const struct bt_field *field); + static bool variant_field_is_set(const struct bt_field *field); +static +struct bt_field_methods bool_field_methods = { + .set_is_frozen = set_single_field_is_frozen, + .is_set = single_field_is_set, + .reset = reset_single_field, +}; + +static +struct bt_field_methods bit_array_field_methods = { + .set_is_frozen = set_single_field_is_frozen, + .is_set = single_field_is_set, + .reset = reset_single_field, +}; + static struct bt_field_methods integer_field_methods = { .set_is_frozen = set_single_field_is_frozen, @@ -109,6 +132,13 @@ struct bt_field_methods array_field_methods = { .reset = reset_array_field, }; +static +struct bt_field_methods option_field_methods = { + .set_is_frozen = set_option_field_is_frozen, + .is_set = option_field_is_set, + .reset = reset_option_field, +}; + static struct bt_field_methods variant_field_methods = { .set_is_frozen = set_variant_field_is_frozen, @@ -116,6 +146,12 @@ struct bt_field_methods variant_field_methods = { .reset = reset_variant_field, }; +static +struct bt_field *create_bool_field(struct bt_field_class *); + +static +struct bt_field *create_bit_array_field(struct bt_field_class *); + static struct bt_field *create_integer_field(struct bt_field_class *); @@ -127,30 +163,48 @@ struct bt_field *create_string_field(struct bt_field_class *); static struct bt_field *create_structure_field(struct bt_field_class *); - static struct bt_field *create_static_array_field(struct bt_field_class *); static struct bt_field *create_dynamic_array_field(struct bt_field_class *); +static +struct bt_field *create_option_field(struct bt_field_class *); + static 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_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, + [BT_FIELD_CLASS_TYPE_BOOL] = create_bool_field, + [BT_FIELD_CLASS_TYPE_BIT_ARRAY] = create_bit_array_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_SINGLE_PRECISION_REAL] = create_real_field, + [BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_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_WITHOUT_LENGTH_FIELD] = create_dynamic_array_field, + [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD] = create_dynamic_array_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD] = create_option_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD] = create_option_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD] = create_option_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD] = create_option_field, + [BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD] = create_variant_field, + [BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD] = create_variant_field, + [BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD] = create_variant_field, }; +static +void destroy_bool_field(struct bt_field *field); + +static +void destroy_bit_array_field(struct bt_field *field); + static void destroy_integer_field(struct bt_field *field); @@ -166,39 +220,52 @@ void destroy_structure_field(struct bt_field *field); static void destroy_array_field(struct bt_field *field); +static +void destroy_option_field(struct bt_field *field); + static void destroy_variant_field(struct bt_field *field); static void (* const field_destroy_funcs[])(struct bt_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, + [BT_FIELD_CLASS_TYPE_BOOL] = destroy_bool_field, + [BT_FIELD_CLASS_TYPE_BIT_ARRAY] = destroy_bit_array_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_SINGLE_PRECISION_REAL] = destroy_real_field, + [BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_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_WITHOUT_LENGTH_FIELD] = destroy_array_field, + [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD] = destroy_array_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD] = destroy_option_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD] = destroy_option_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD] = destroy_option_field, + [BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD] = destroy_option_field, + [BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD] = destroy_variant_field, + [BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD] = destroy_variant_field, + [BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD] = destroy_variant_field, }; -struct bt_field_class *bt_field_borrow_class(const struct bt_field *field) +struct bt_field_class *bt_field_borrow_class(struct bt_field *field) { - BT_ASSERT_PRE_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_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"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); return field->class; } enum bt_field_class_type bt_field_get_class_type(const struct bt_field *field) { - BT_ASSERT_PRE_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); return field->class->type; } @@ -207,11 +274,10 @@ 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_type(fc)); + BT_ASSERT(fc); field = field_create_funcs[fc->type](fc); if (!field) { - BT_LIB_LOGE("Cannot create field object from field class: " + BT_LIB_LOGE_APPEND_CAUSE("Cannot create field object from field class: " "%![fc-]+F", fc); goto end; } @@ -229,7 +295,47 @@ void init_field(struct bt_field *field, struct bt_field_class *fc, bt_object_init_unique(&field->base); field->methods = methods; field->class = fc; - bt_object_get_no_null_check(fc); + bt_object_get_ref_no_null_check(fc); +} + +static +struct bt_field *create_bool_field(struct bt_field_class *fc) +{ + struct bt_field_bool *bool_field; + + BT_LIB_LOGD("Creating boolean field object: %![fc-]+F", fc); + bool_field = g_new0(struct bt_field_bool, 1); + if (!bool_field) { + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one boolean field."); + goto end; + } + + init_field((void *) bool_field, fc, &bool_field_methods); + BT_LIB_LOGD("Created boolean field object: %!+f", bool_field); + +end: + return (void *) bool_field; +} + +static +struct bt_field *create_bit_array_field(struct bt_field_class *fc) +{ + struct bt_field_bit_array *ba_field; + + BT_LIB_LOGD("Creating bit array field object: %![fc-]+F", fc); + ba_field = g_new0(struct bt_field_bit_array, 1); + if (!ba_field) { + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one bit array field."); + goto end; + } + + init_field((void *) ba_field, fc, &bit_array_field_methods); + BT_LIB_LOGD("Created bit array field object: %!+f", ba_field); + +end: + return (void *) ba_field; } static @@ -240,7 +346,8 @@ struct bt_field *create_integer_field(struct bt_field_class *fc) BT_LIB_LOGD("Creating integer field object: %![fc-]+F", fc); int_field = g_new0(struct bt_field_integer, 1); if (!int_field) { - BT_LOGE_STR("Failed to allocate one integer field."); + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one integer field."); goto end; } @@ -259,7 +366,7 @@ struct bt_field *create_real_field(struct bt_field_class *fc) BT_LIB_LOGD("Creating real field object: %![fc-]+F", fc); real_field = g_new0(struct bt_field_real, 1); if (!real_field) { - BT_LOGE_STR("Failed to allocate one real field."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one real field."); goto end; } @@ -278,7 +385,8 @@ struct bt_field *create_string_field(struct bt_field_class *fc) BT_LIB_LOGD("Creating string field object: %![fc-]+F", fc); string_field = g_new0(struct bt_field_string, 1); if (!string_field) { - BT_LOGE_STR("Failed to allocate one string field."); + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one string field."); goto end; } @@ -286,8 +394,9 @@ struct bt_field *create_string_field(struct bt_field_class *fc) string_field->buf = g_array_sized_new(FALSE, FALSE, sizeof(char), 1); if (!string_field->buf) { - BT_LOGE_STR("Failed to allocate a GArray."); - BT_OBJECT_PUT_REF_AND_RESET(string_field); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GArray."); + bt_field_destroy((void *) string_field); + string_field = NULL; goto end; } @@ -309,7 +418,7 @@ int create_fields_from_named_field_classes( *fields = g_ptr_array_new_with_free_func( (GDestroyNotify) bt_field_destroy); if (!*fields) { - BT_LOGE_STR("Failed to allocate a GPtrArray."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray."); ret = -1; goto end; } @@ -318,12 +427,12 @@ int create_fields_from_named_field_classes( for (i = 0; i < fc->named_fcs->len; i++) { struct bt_field *field; - struct bt_named_field_class *named_fc = - BT_FIELD_CLASS_NAMED_FC_AT_INDEX(fc, i); + struct bt_named_field_class *named_fc = fc->named_fcs->pdata[i]; field = bt_field_create(named_fc->fc); if (!field) { - BT_LIB_LOGE("Failed to create structure member or variant option field: " + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to create structure member or variant option field: " "name=\"%s\", %![fc-]+F", named_fc->name->str, named_fc->fc); ret = -1; @@ -345,7 +454,8 @@ struct bt_field *create_structure_field(struct bt_field_class *fc) BT_LIB_LOGD("Creating structure field object: %![fc-]+F", fc); struct_field = g_new0(struct bt_field_structure, 1); if (!struct_field) { - BT_LOGE_STR("Failed to allocate one structure field."); + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one structure field."); goto end; } @@ -353,9 +463,10 @@ struct bt_field *create_structure_field(struct bt_field_class *fc) if (create_fields_from_named_field_classes((void *) fc, &struct_field->fields)) { - BT_LIB_LOGE("Cannot create structure member fields: " - "%![fc-]+F", fc); - BT_OBJECT_PUT_REF_AND_RESET(struct_field); + BT_LIB_LOGE_APPEND_CAUSE( + "Cannot create structure member fields: %![fc-]+F", fc); + bt_field_destroy((void *) struct_field); + struct_field = NULL; goto end; } @@ -365,6 +476,38 @@ end: return (void *) struct_field; } +static +struct bt_field *create_option_field(struct bt_field_class *fc) +{ + struct bt_field_option *opt_field; + struct bt_field_class_option *opt_fc = (void *) fc; + + BT_LIB_LOGD("Creating option field object: %![fc-]+F", fc); + opt_field = g_new0(struct bt_field_option, 1); + if (!opt_field) { + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one option field."); + goto end; + } + + init_field((void *) opt_field, fc, &option_field_methods); + opt_field->content_field = bt_field_create(opt_fc->content_fc); + if (!opt_field->content_field) { + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to create option field's content field: " + "%![opt-fc-]+F, %![content-fc-]+F", + opt_fc, opt_fc->content_fc); + bt_field_destroy((void *) opt_field); + opt_field = NULL; + goto end; + } + + BT_LIB_LOGD("Created option field object: %!+f", opt_field); + +end: + return (void *) opt_field; +} + static struct bt_field *create_variant_field(struct bt_field_class *fc) { @@ -373,7 +516,8 @@ struct bt_field *create_variant_field(struct bt_field_class *fc) BT_LIB_LOGD("Creating variant field object: %![fc-]+F", fc); var_field = g_new0(struct bt_field_variant, 1); if (!var_field) { - BT_LOGE_STR("Failed to allocate one variant field."); + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one variant field."); goto end; } @@ -381,9 +525,10 @@ struct bt_field *create_variant_field(struct bt_field_class *fc) if (create_fields_from_named_field_classes((void *) fc, &var_field->fields)) { - BT_LIB_LOGE("Cannot create variant member fields: " + BT_LIB_LOGE_APPEND_CAUSE("Cannot create variant member fields: " "%![fc-]+F", fc); - BT_OBJECT_PUT_REF_AND_RESET(var_field); + bt_field_destroy((void *) var_field); + var_field = NULL; goto end; } @@ -404,7 +549,7 @@ int init_array_field_fields(struct bt_field_array *array_field) array_fc = (void *) array_field->common.class; array_field->fields = g_ptr_array_sized_new(array_field->length); if (!array_field->fields) { - BT_LOGE_STR("Failed to allocate a GPtrArray."); + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray."); ret = -1; goto end; } @@ -417,7 +562,8 @@ int init_array_field_fields(struct bt_field_array *array_field) array_field->fields->pdata[i] = bt_field_create( array_fc->element_fc); if (!array_field->fields->pdata[i]) { - BT_LIB_LOGE("Cannot create array field's element field: " + BT_LIB_LOGE_APPEND_CAUSE( + "Cannot create array field's element field: " "index=%" PRIu64 ", %![fc-]+F", i, array_fc); ret = -1; goto end; @@ -431,13 +577,14 @@ end: static struct bt_field *create_static_array_field(struct bt_field_class *fc) { - struct bt_field_class_static_array *array_fc = (void *) fc; + struct bt_field_class_array_static *array_fc = (void *) fc; struct bt_field_array *array_field; BT_LIB_LOGD("Creating static array field object: %![fc-]+F", fc); array_field = g_new0(struct bt_field_array, 1); if (!array_field) { - BT_LOGE_STR("Failed to allocate one static array field."); + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one static array field."); goto end; } @@ -445,9 +592,10 @@ struct bt_field *create_static_array_field(struct bt_field_class *fc) array_field->length = array_fc->length; if (init_array_field_fields(array_field)) { - BT_LIB_LOGE("Cannot create static array fields: " + BT_LIB_LOGE_APPEND_CAUSE("Cannot create static array fields: " "%![fc-]+F", fc); - BT_OBJECT_PUT_REF_AND_RESET(array_field); + bt_field_destroy((void *) array_field); + array_field = NULL; goto end; } @@ -465,16 +613,18 @@ struct bt_field *create_dynamic_array_field(struct bt_field_class *fc) BT_LIB_LOGD("Creating dynamic array field object: %![fc-]+F", fc); array_field = g_new0(struct bt_field_array, 1); if (!array_field) { - BT_LOGE_STR("Failed to allocate one dynamic array field."); + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to allocate one dynamic array field."); goto end; } init_field((void *) array_field, fc, &array_field_methods); if (init_array_field_fields(array_field)) { - BT_LIB_LOGE("Cannot create dynamic array fields: " + BT_LIB_LOGE_APPEND_CAUSE("Cannot create dynamic array fields: " "%![fc-]+F", fc); - BT_OBJECT_PUT_REF_AND_RESET(array_field); + bt_field_destroy((void *) array_field); + array_field = NULL; goto end; } @@ -484,24 +634,79 @@ end: return (void *) array_field; } -int64_t bt_field_signed_integer_get_value(const struct bt_field *field) +bt_bool bt_field_bool_get_value(const struct bt_field *field) +{ + const struct bt_field_bool *bool_field = (const void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_BOOL, + "Field"); + return (bt_bool) bool_field->value; +} + +void bt_field_bool_set_value(struct bt_field *field, bt_bool value) +{ + struct bt_field_bool *bool_field = (void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_BOOL, + "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + bool_field->value = (bool) value; + bt_field_set_single(field, true); +} + +uint64_t bt_field_bit_array_get_value_as_integer(const struct bt_field *field) +{ + const struct bt_field_bit_array *ba_field = (const void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_BIT_ARRAY, "Field"); + return ba_field->value_as_int; +} + +void bt_field_bit_array_set_value_as_integer(struct bt_field *field, + uint64_t value) +{ + struct bt_field_bit_array *ba_field = (void *) field; + struct bt_field_class_bit_array *ba_fc; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_BIT_ARRAY, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + ba_fc = (void *) field->class; + ba_field->value_as_int = value; + + if (ba_fc->length < 64) { + /* Apply mask */ + ba_field->value_as_int &= ((UINT64_C(1) << ba_fc->length) - 1); + } + + bt_field_set_single(field, true); +} + +int64_t bt_field_integer_signed_get_value(const struct bt_field *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"); - BT_ASSERT_PRE_FIELD_IS_SIGNED_INT(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SIGNED_INT(field, "Field"); return int_field->value.i; } -void bt_field_signed_integer_set_value(struct bt_field *field, int64_t value) +void bt_field_integer_signed_set_value(struct bt_field *field, int64_t value) { struct bt_field_integer *int_field = (void *) field; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_FIELD_IS_SIGNED_INT(field, "Field"); - BT_ASSERT_PRE_FIELD_HOT(field, "Field"); - BT_ASSERT_PRE(bt_util_value_is_in_range_signed( + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SIGNED_INT(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV(bt_util_value_is_in_range_signed( ((struct bt_field_class_integer *) field->class)->range, value), "Value is out of bounds: value=%" PRId64 ", %![field-]+f, " "%![fc-]+F", value, field, field->class); @@ -509,24 +714,24 @@ 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(const struct bt_field *field) +uint64_t bt_field_integer_unsigned_get_value(const struct bt_field *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"); - BT_ASSERT_PRE_FIELD_IS_UNSIGNED_INT(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_UNSIGNED_INT(field, "Field"); return int_field->value.u; } -void bt_field_unsigned_integer_set_value(struct bt_field *field, uint64_t value) +void bt_field_integer_unsigned_set_value(struct bt_field *field, uint64_t value) { struct bt_field_integer *int_field = (void *) field; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_FIELD_IS_UNSIGNED_INT(field, "Field"); - BT_ASSERT_PRE_FIELD_HOT(field, "Field"); - BT_ASSERT_PRE(bt_util_value_is_in_range_unsigned( + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_UNSIGNED_INT(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV(bt_util_value_is_in_range_unsigned( ((struct bt_field_class_integer *) field->class)->range, value), "Value is out of bounds: value=%" PRIu64 ", %![field-]+f, " "%![fc-]+F", value, field, field->class); @@ -534,67 +739,92 @@ void bt_field_unsigned_integer_set_value(struct bt_field *field, uint64_t value) bt_field_set_single(field, true); } -double bt_field_real_get_value(const struct bt_field *field) +float bt_field_real_single_precision_get_value(const struct bt_field *field) +{ + const struct bt_field_real *real_field = (const void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL, "Field"); + return (float) real_field->value; +} + +double bt_field_real_double_precision_get_value(const struct bt_field *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_TYPE(field, BT_FIELD_CLASS_TYPE_REAL, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL, "Field"); + return real_field->value; } -void bt_field_real_set_value(struct bt_field *field, double value) +void bt_field_real_single_precision_set_value(struct bt_field *field, + float value) +{ + struct bt_field_real *real_field = (void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + + real_field->value = (double) value; + bt_field_set_single(field, true); +} + +void bt_field_real_double_precision_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_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 || - (double) (float) value == value, - "Invalid value for a single-precision real number: value=%f, " - "%![fc-]+F", value, field->class); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + real_field->value = value; bt_field_set_single(field, true); } enum bt_field_enumeration_get_mapping_labels_status -bt_field_unsigned_enumeration_get_mapping_labels( +bt_field_enumeration_unsigned_get_mapping_labels( const struct bt_field *field, bt_field_class_enumeration_mapping_label_array *label_array, uint64_t *count) { 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_TYPE(field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Label array (output)"); + BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Count (output)"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION, "Field"); return (int) - bt_field_class_unsigned_enumeration_get_mapping_labels_by_value( + bt_field_class_enumeration_unsigned_get_mapping_labels_for_value( field->class, int_field->value.u, label_array, count); } enum bt_field_enumeration_get_mapping_labels_status -bt_field_signed_enumeration_get_mapping_labels( +bt_field_enumeration_signed_get_mapping_labels( const struct bt_field *field, bt_field_class_enumeration_mapping_label_array *label_array, uint64_t *count) { 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_TYPE(field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Label array (output)"); + BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Count (output)"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION, "Field"); return (int) - bt_field_class_signed_enumeration_get_mapping_labels_by_value( + bt_field_class_enumeration_signed_get_mapping_labels_for_value( field->class, int_field->value.i, label_array, count); } @@ -602,9 +832,9 @@ const char *bt_field_string_get_value(const struct bt_field *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_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, "Field"); return (const char *) string_field->buf->data; } @@ -613,9 +843,9 @@ uint64_t bt_field_string_get_length(const struct bt_field *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_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, "Field"); return string_field->length; } @@ -633,10 +863,10 @@ void clear_string_field(struct bt_field *field) enum bt_field_string_set_value_status 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_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(value, "Value"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, "Field"); clear_string_field(field); return (int) bt_field_string_append_with_length(field, value, @@ -657,14 +887,14 @@ enum bt_field_string_append_status bt_field_string_append_with_length( char *data; uint64_t new_length; - 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_TYPE(field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(value, "Value"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV_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, + BT_ASSERT_PRE_DEV(!memchr(value, '\0', length), "String value to append contains a null character: " "partial-value=\"%.32s\", length=%" PRIu64, value, length); @@ -684,9 +914,9 @@ enum bt_field_string_append_status bt_field_string_append_with_length( void 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_TYPE(field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING, "Field"); clear_string_field(field); } @@ -695,21 +925,20 @@ uint64_t bt_field_array_get_length(const struct bt_field *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"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_ARRAY(field, "Field"); return array_field->length; } -enum bt_field_dynamic_array_set_length_status bt_field_dynamic_array_set_length( +enum bt_field_array_dynamic_set_length_status bt_field_array_dynamic_set_length( struct bt_field *field, uint64_t length) { int ret = BT_FUNC_STATUS_OK; struct bt_field_array *array_field = (void *) field; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, - BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY, "Field"); - BT_ASSERT_PRE_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_DYNAMIC_ARRAY(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); if (G_UNLIKELY(length > array_field->fields->len)) { /* Make more room */ @@ -725,7 +954,8 @@ enum bt_field_dynamic_array_set_length_status bt_field_dynamic_array_set_length( array_fc->element_fc); if (!elem_field) { - BT_LIB_LOGE("Cannot create element field for " + BT_LIB_LOGE_APPEND_CAUSE( + "Cannot create element field for " "dynamic array field: " "index=%" PRIu64 ", " "%![array-field-]+f", i, field); @@ -750,9 +980,9 @@ struct bt_field *borrow_array_field_element_field_by_index( { struct bt_field_array *array_field = (void *) field; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_FIELD_IS_ARRAY(field, "Field"); - BT_ASSERT_PRE_VALID_INDEX(index, array_field->length); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_ARRAY(field, "Field"); + BT_ASSERT_PRE_DEV_VALID_INDEX(index, array_field->length); return array_field->fields->pdata[index]; } @@ -775,10 +1005,10 @@ struct bt_field *borrow_structure_field_member_field_by_index( { struct bt_field_structure *struct_field = (void *) field; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRUCTURE, "Field"); - BT_ASSERT_PRE_VALID_INDEX(index, struct_field->fields->len); + BT_ASSERT_PRE_DEV_VALID_INDEX(index, struct_field->fields->len); return struct_field->fields->pdata[index]; } @@ -807,9 +1037,9 @@ struct bt_field *borrow_structure_field_member_field_by_name( gpointer orig_key; gpointer index; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_NON_NULL(name, "Field name"); - BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_NON_NULL(name, "Field name"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRUCTURE, "Field"); struct_fc = (void *) field->class; @@ -838,16 +1068,45 @@ const struct bt_field *bt_field_structure_borrow_member_field_by_name_const( (void *) field, name); } +void bt_field_option_set_has_field(struct bt_field *field, bt_bool has_field) +{ + struct bt_field_option *opt_field = (void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_OPTION(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + + if (has_field) { + opt_field->selected_field = opt_field->content_field; + } else { + opt_field->selected_field = NULL; + } +} + +struct bt_field *bt_field_option_borrow_field(struct bt_field *field) +{ + struct bt_field_option *opt_field = (void *) field; + + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_OPTION(field, "Field"); + return opt_field->selected_field; +} + +const struct bt_field *bt_field_option_borrow_field_const( + const struct bt_field *field) +{ + return (const void *) bt_field_option_borrow_field((void *) field); +} + 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_TYPE(field, - BT_FIELD_CLASS_TYPE_VARIANT, "Field"); - BT_ASSERT_PRE(var_field->selected_field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field"); + BT_ASSERT_PRE_DEV(var_field->selected_field, "Variant field has no selected field: %!+f", field); return var_field->selected_field; } @@ -864,17 +1123,59 @@ const struct bt_field *bt_field_variant_borrow_selected_option_field_const( return borrow_variant_field_selected_option_field((void *) field); } -enum bt_field_variant_select_option_field_status -bt_field_variant_select_option_field( +static +const struct bt_field_class_variant_option * +borrow_variant_field_selected_class_option(const struct bt_field *field) +{ + const struct bt_field_class_named_field_class_container *container_fc; + const struct bt_field_variant *var_field = (const void *) field; + + BT_ASSERT(field); + BT_ASSERT_PRE_DEV(var_field->selected_field, + "Variant field has no selected field: %!+f", field); + container_fc = (const void *) field->class; + return container_fc->named_fcs->pdata[var_field->selected_index]; +} + +const struct bt_field_class_variant_option * +bt_field_variant_borrow_selected_class_option_const( + const struct bt_field *field) +{ + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field"); + return borrow_variant_field_selected_class_option(field); +} + +const struct bt_field_class_variant_with_selector_field_integer_unsigned_option * +bt_field_variant_with_unsigned_integer_selector_borrow_selected_class_option_const( + const struct bt_field *field) +{ + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD, "Field"); + return (const void *) borrow_variant_field_selected_class_option(field); +} + +const struct bt_field_class_variant_with_selector_field_integer_signed_option * +bt_field_variant_with_signed_integer_selector_borrow_selected_class_option_const( + const struct bt_field *field) +{ + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, + BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD, "Field"); + return (const void *) borrow_variant_field_selected_class_option(field); +} + +enum bt_field_variant_select_option_field_by_index_status +bt_field_variant_select_option_field_by_index( 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_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); + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field"); + BT_ASSERT_PRE_DEV_VALID_INDEX(index, var_field->fields->len); var_field->selected_field = var_field->fields->pdata[index]; var_field->selected_index = index; return BT_FUNC_STATUS_OK; @@ -885,10 +1186,9 @@ uint64_t bt_field_variant_get_selected_option_field_index( { const struct bt_field_variant *var_field = (const void *) field; - BT_ASSERT_PRE_NON_NULL(field, "Field"); - BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, - BT_FIELD_CLASS_TYPE_VARIANT, "Field"); - BT_ASSERT_PRE(var_field->selected_field, + BT_ASSERT_PRE_DEV_NON_NULL(field, "Field"); + BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field"); + BT_ASSERT_PRE_DEV(var_field->selected_field, "Variant field has no selected field: %!+f", field); return var_field->selected_index; } @@ -901,6 +1201,24 @@ void bt_field_finalize(struct bt_field *field) BT_OBJECT_PUT_REF_AND_RESET(field->class); } +static +void destroy_bool_field(struct bt_field *field) +{ + BT_ASSERT(field); + BT_LIB_LOGD("Destroying boolean field object: %!+f", field); + bt_field_finalize(field); + g_free(field); +} + +static +void destroy_bit_array_field(struct bt_field *field) +{ + BT_ASSERT(field); + BT_LIB_LOGD("Destroying bit array field object: %!+f", field); + bt_field_finalize(field); + g_free(field); +} + static void destroy_integer_field(struct bt_field *field) { @@ -936,6 +1254,22 @@ void destroy_structure_field(struct bt_field *field) g_free(field); } +static +void destroy_option_field(struct bt_field *field) +{ + struct bt_field_option *opt_field = (void *) field; + + BT_ASSERT(field); + BT_LIB_LOGD("Destroying option field object: %!+f", field); + bt_field_finalize(field); + + if (opt_field->content_field) { + bt_field_destroy(opt_field->content_field); + } + + g_free(field); +} + static void destroy_variant_field(struct bt_field *field) { @@ -991,7 +1325,6 @@ BT_HIDDEN void bt_field_destroy(struct bt_field *field) { BT_ASSERT(field); - BT_ASSERT(bt_field_class_has_known_type(field->class)); field_destroy_funcs[field->class->type](field); } @@ -1015,6 +1348,16 @@ void reset_structure_field(struct bt_field *field) } } +static +void reset_option_field(struct bt_field *field) +{ + struct bt_field_option *opt_field = (void *) field; + + BT_ASSERT(opt_field); + bt_field_reset(opt_field->content_field); + opt_field->selected_field = NULL; +} + static void reset_variant_field(struct bt_field *field) { @@ -1062,12 +1405,23 @@ void set_structure_field_is_frozen(struct bt_field *field, bool is_frozen) BT_LIB_LOGD("Setting structure field's member field's " "frozen state: %![field-]+f, index=%" PRIu64, member_field, i); - bt_field_set_is_frozen(member_field, is_frozen); + _bt_field_set_is_frozen(member_field, is_frozen); } set_single_field_is_frozen(field, is_frozen); } +static +void set_option_field_is_frozen(struct bt_field *field, bool is_frozen) +{ + struct bt_field_option *opt_field = (void *) field; + + BT_LIB_LOGD("Setting option field's frozen state: " + "%![field-]+f, is-frozen=%d", field, is_frozen); + _bt_field_set_is_frozen(opt_field->content_field, is_frozen); + set_single_field_is_frozen(field, is_frozen); +} + static void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen) { @@ -1083,7 +1437,7 @@ void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen) BT_LIB_LOGD("Setting variant field's option field's " "frozen state: %![field-]+f, index=%" PRIu64, option_field, i); - bt_field_set_is_frozen(option_field, is_frozen); + _bt_field_set_is_frozen(option_field, is_frozen); } set_single_field_is_frozen(field, is_frozen); @@ -1104,7 +1458,7 @@ void set_array_field_is_frozen(struct bt_field *field, bool is_frozen) BT_LIB_LOGD("Setting array field's element field's " "frozen state: %![field-]+f, index=%" PRIu64, elem_field, i); - bt_field_set_is_frozen(elem_field, is_frozen); + _bt_field_set_is_frozen(elem_field, is_frozen); } set_single_field_is_frozen(field, is_frozen); @@ -1148,6 +1502,21 @@ end: return is_set; } +static +bool option_field_is_set(const struct bt_field *field) +{ + const struct bt_field_option *opt_field = (const void *) field; + bool is_set = false; + + BT_ASSERT(field); + + if (opt_field->selected_field) { + is_set = bt_field_is_set(opt_field->selected_field); + } + + return is_set; +} + static bool variant_field_is_set(const struct bt_field *field) {