4 * Babeltrace CTF IR - Event Fields
6 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 #define BT_LOG_TAG "FIELDS"
30 #include <babeltrace/lib-logging-internal.h>
32 #include <babeltrace/assert-pre-internal.h>
33 #include <babeltrace/ctf-ir/fields-internal.h>
34 #include <babeltrace/ctf-ir/field-types-internal.h>
35 #include <babeltrace/object-internal.h>
36 #include <babeltrace/ref.h>
37 #include <babeltrace/compiler-internal.h>
38 #include <babeltrace/compat/fcntl-internal.h>
39 #include <babeltrace/align-internal.h>
40 #include <babeltrace/assert-internal.h>
43 #define BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(_field, _name) \
44 BT_ASSERT_PRE((_field)->type->id == BT_FIELD_TYPE_ID_INTEGER || \
45 (_field)->type->id == BT_FIELD_TYPE_ID_ENUM, \
46 _name " is not an integer or an enumeration field: " \
49 static struct bt_field_common_methods bt_field_integer_methods
= {
50 .set_is_frozen
= bt_field_common_generic_set_is_frozen
,
51 .validate
= bt_field_common_generic_validate
,
53 .is_set
= bt_field_common_generic_is_set
,
54 .reset
= bt_field_common_generic_reset
,
57 static struct bt_field_common_methods bt_field_floating_point_methods
= {
58 .set_is_frozen
= bt_field_common_generic_set_is_frozen
,
59 .validate
= bt_field_common_generic_validate
,
61 .is_set
= bt_field_common_generic_is_set
,
62 .reset
= bt_field_common_generic_reset
,
65 static struct bt_field_common_methods bt_field_enumeration_methods
= {
66 .set_is_frozen
= bt_field_common_generic_set_is_frozen
,
67 .validate
= bt_field_common_generic_validate
,
69 .is_set
= bt_field_common_generic_is_set
,
70 .reset
= bt_field_common_generic_reset
,
73 static struct bt_field_common_methods bt_field_string_methods
= {
74 .set_is_frozen
= bt_field_common_generic_set_is_frozen
,
75 .validate
= bt_field_common_generic_validate
,
77 .is_set
= bt_field_common_generic_is_set
,
78 .reset
= bt_field_common_generic_reset
,
81 static struct bt_field_common_methods bt_field_structure_methods
= {
82 .set_is_frozen
= bt_field_common_structure_set_is_frozen_recursive
,
83 .validate
= bt_field_common_structure_validate_recursive
,
85 .is_set
= bt_field_common_structure_is_set_recursive
,
86 .reset
= bt_field_common_structure_reset_recursive
,
89 static struct bt_field_common_methods bt_field_sequence_methods
= {
90 .set_is_frozen
= bt_field_common_sequence_set_is_frozen_recursive
,
91 .validate
= bt_field_common_sequence_validate_recursive
,
93 .is_set
= bt_field_common_sequence_is_set_recursive
,
94 .reset
= bt_field_common_sequence_reset_recursive
,
97 static struct bt_field_common_methods bt_field_array_methods
= {
98 .set_is_frozen
= bt_field_common_array_set_is_frozen_recursive
,
99 .validate
= bt_field_common_array_validate_recursive
,
101 .is_set
= bt_field_common_array_is_set_recursive
,
102 .reset
= bt_field_common_array_reset_recursive
,
105 static struct bt_field_common_methods bt_field_variant_methods
= {
106 .set_is_frozen
= bt_field_common_variant_set_is_frozen_recursive
,
107 .validate
= bt_field_common_variant_validate_recursive
,
109 .is_set
= bt_field_common_variant_is_set_recursive
,
110 .reset
= bt_field_common_variant_reset_recursive
,
114 struct bt_field
*bt_field_integer_create(struct bt_field_type
*);
117 struct bt_field
*bt_field_enumeration_create(struct bt_field_type
*);
120 struct bt_field
*bt_field_floating_point_create(struct bt_field_type
*);
123 struct bt_field
*bt_field_structure_create(struct bt_field_type
*);
126 struct bt_field
*bt_field_variant_create(struct bt_field_type
*);
129 struct bt_field
*bt_field_array_create(struct bt_field_type
*);
132 struct bt_field
*bt_field_sequence_create(struct bt_field_type
*);
135 struct bt_field
*bt_field_string_create(struct bt_field_type
*);
138 struct bt_field
*(* const field_create_funcs
[])(struct bt_field_type
*) = {
139 [BT_FIELD_TYPE_ID_INTEGER
] = bt_field_integer_create
,
140 [BT_FIELD_TYPE_ID_ENUM
] = bt_field_enumeration_create
,
141 [BT_FIELD_TYPE_ID_FLOAT
] = bt_field_floating_point_create
,
142 [BT_FIELD_TYPE_ID_STRUCT
] = bt_field_structure_create
,
143 [BT_FIELD_TYPE_ID_VARIANT
] = bt_field_variant_create
,
144 [BT_FIELD_TYPE_ID_ARRAY
] = bt_field_array_create
,
145 [BT_FIELD_TYPE_ID_SEQUENCE
] = bt_field_sequence_create
,
146 [BT_FIELD_TYPE_ID_STRING
] = bt_field_string_create
,
150 void bt_field_integer_destroy(struct bt_field
*field
);
153 void bt_field_enumeration_destroy(struct bt_field
*field
);
156 void bt_field_floating_point_destroy(struct bt_field
*field
);
159 void bt_field_structure_destroy_recursive(struct bt_field
*field
);
162 void bt_field_variant_destroy_recursive(struct bt_field
*field
);
165 void bt_field_array_destroy_recursive(struct bt_field
*field
);
168 void bt_field_sequence_destroy_recursive(struct bt_field
*field
);
171 void bt_field_string_destroy(struct bt_field
*field
);
174 void (* const field_destroy_funcs
[])(struct bt_field
*) = {
175 [BT_FIELD_TYPE_ID_INTEGER
] = bt_field_integer_destroy
,
176 [BT_FIELD_TYPE_ID_ENUM
] = bt_field_enumeration_destroy
,
177 [BT_FIELD_TYPE_ID_FLOAT
] = bt_field_floating_point_destroy
,
178 [BT_FIELD_TYPE_ID_STRUCT
] = bt_field_structure_destroy_recursive
,
179 [BT_FIELD_TYPE_ID_VARIANT
] = bt_field_variant_destroy_recursive
,
180 [BT_FIELD_TYPE_ID_ARRAY
] = bt_field_array_destroy_recursive
,
181 [BT_FIELD_TYPE_ID_SEQUENCE
] = bt_field_sequence_destroy_recursive
,
182 [BT_FIELD_TYPE_ID_STRING
] = bt_field_string_destroy
,
186 struct bt_field
*bt_field_create_recursive(struct bt_field_type
*type
)
188 struct bt_field
*field
= NULL
;
189 enum bt_field_type_id type_id
;
191 BT_ASSERT_PRE_NON_NULL(type
, "Field type");
192 BT_ASSERT(field_type_common_has_known_id((void *) type
));
193 BT_ASSERT_PRE(bt_field_type_common_validate((void *) type
) == 0,
194 "Field type is invalid: %!+F", type
);
195 type_id
= bt_field_type_get_type_id(type
);
196 field
= field_create_funcs
[type_id
](type
);
201 bt_field_type_freeze(type
);
207 struct bt_field_type
*bt_field_borrow_type(struct bt_field
*field
)
209 return (void *) bt_field_common_borrow_type((void *) field
);
212 enum bt_field_type_id
bt_field_get_type_id(struct bt_field
*field
)
214 struct bt_field_common
*field_common
= (void *) field
;
216 BT_ASSERT_PRE_NON_NULL(field
, "Field");
217 return field_common
->type
->id
;
220 bt_bool
bt_field_is_integer(struct bt_field
*field
)
222 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_INTEGER
;
225 bt_bool
bt_field_is_floating_point(struct bt_field
*field
)
227 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_FLOAT
;
230 bt_bool
bt_field_is_enumeration(struct bt_field
*field
)
232 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_ENUM
;
235 bt_bool
bt_field_is_string(struct bt_field
*field
)
237 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_STRING
;
240 bt_bool
bt_field_is_structure(struct bt_field
*field
)
242 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_STRUCT
;
245 bt_bool
bt_field_is_array(struct bt_field
*field
)
247 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_ARRAY
;
250 bt_bool
bt_field_is_sequence(struct bt_field
*field
)
252 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_SEQUENCE
;
255 bt_bool
bt_field_is_variant(struct bt_field
*field
)
257 return bt_field_get_type_id(field
) == BT_FIELD_TYPE_ID_VARIANT
;
260 int64_t bt_field_sequence_get_length(struct bt_field
*field
)
262 return bt_field_common_sequence_get_length((void *) field
);
265 int bt_field_sequence_set_length(struct bt_field
*field
, uint64_t length
)
267 return bt_field_common_sequence_set_length((void *) field
,
268 length
, (bt_field_common_create_func
) bt_field_create_recursive
);
271 struct bt_field
*bt_field_structure_borrow_field_by_index(
272 struct bt_field
*field
, uint64_t index
)
274 return (void *) bt_field_common_structure_borrow_field_by_index(
275 (void *) field
, index
);
278 struct bt_field
*bt_field_structure_borrow_field_by_name(
279 struct bt_field
*field
, const char *name
)
281 return (void *) bt_field_common_structure_borrow_field_by_name(
282 (void *) field
, name
);
285 struct bt_field
*bt_field_array_borrow_field(
286 struct bt_field
*field
, uint64_t index
)
288 return (void *) bt_field_common_array_borrow_field((void *) field
,
292 struct bt_field
*bt_field_sequence_borrow_field(
293 struct bt_field
*field
, uint64_t index
)
295 return (void *) bt_field_common_sequence_borrow_field((void *) field
,
299 struct bt_field
*bt_field_variant_borrow_current_field(
300 struct bt_field
*variant_field
)
302 return (void *) bt_field_common_variant_borrow_current_field(
303 (void *) variant_field
);
306 int bt_field_variant_set_tag_signed(struct bt_field
*variant_field
,
309 return bt_field_variant_common_set_tag((void *) variant_field
,
310 (uint64_t) tag
, true);
313 int bt_field_variant_set_tag_unsigned(struct bt_field
*variant_field
,
316 return bt_field_variant_common_set_tag((void *) variant_field
,
317 (uint64_t) tag
, false);
320 int bt_field_variant_get_tag_signed(struct bt_field
*variant_field
,
323 return bt_field_common_variant_get_tag_signed((void *) variant_field
, tag
);
326 int bt_field_variant_get_tag_unsigned(struct bt_field
*variant_field
,
329 return bt_field_common_variant_get_tag_unsigned((void *) variant_field
, tag
);
332 struct bt_field_type_enumeration_mapping_iterator
*
333 bt_field_enumeration_get_mappings(struct bt_field
*field
)
335 struct bt_field_enumeration
*enum_field
= (void *) field
;
337 BT_ASSERT_PRE_NON_NULL(field
, "Enumeration field");
338 BT_ASSERT_PRE_FIELD_COMMON_HAS_TYPE_ID((struct bt_field_common
*) field
,
339 BT_FIELD_TYPE_ID_ENUM
, "Field");
340 BT_ASSERT_PRE_FIELD_COMMON_IS_SET((struct bt_field_common
*) field
,
341 "Enumeration field");
342 return bt_field_common_enumeration_get_mappings((void *) field
,
343 (bt_field_common_create_func
) bt_field_create_recursive
,
344 enum_field
->common
.payload
.unsignd
);
349 struct bt_field_type_common_integer
*get_int_enum_int_ft(
350 struct bt_field
*field
)
352 struct bt_field_common_integer
*int_field
= (void *) field
;
353 struct bt_field_type_common_integer
*int_ft
= NULL
;
355 if (int_field
->common
.type
->id
== BT_FIELD_TYPE_ID_INTEGER
) {
356 int_ft
= BT_FROM_COMMON(int_field
->common
.type
);
357 } else if (int_field
->common
.type
->id
== BT_FIELD_TYPE_ID_ENUM
) {
358 struct bt_field_type_common_enumeration
*enum_ft
=
359 BT_FROM_COMMON(int_field
->common
.type
);
360 int_ft
= enum_ft
->container_ft
;
367 int bt_field_integer_signed_get_value(struct bt_field
*field
, int64_t *value
)
369 struct bt_field_common_integer
*integer
= (void *) field
;
371 BT_ASSERT_PRE_NON_NULL(field
, "Integer/enumeration field");
372 BT_ASSERT_PRE_NON_NULL(value
, "Value");
373 BT_ASSERT_PRE_FIELD_COMMON_IS_SET(BT_TO_COMMON(integer
),
374 "Integer/enumeration field");
375 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer
), "Field");
376 BT_ASSERT_PRE(bt_field_type_common_integer_is_signed(
377 BT_TO_COMMON(get_int_enum_int_ft(field
))),
378 "Field's type is unsigned: %!+f", field
);
379 *value
= integer
->payload
.signd
;
383 int bt_field_integer_signed_set_value(struct bt_field
*field
, int64_t value
)
386 struct bt_field_common_integer
*integer
= (void *) field
;
388 BT_ASSERT_PRE_NON_NULL(field
, "Integer field");
389 BT_ASSERT_PRE_FIELD_COMMON_HOT(BT_TO_COMMON(integer
), "Integer field");
390 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer
), "Field");
391 BT_ASSERT_PRE(bt_field_type_common_integer_is_signed(
392 BT_FROM_COMMON(get_int_enum_int_ft(field
))),
393 "Field's type is unsigned: %!+f", field
);
394 BT_ASSERT_PRE(value_is_in_range_signed(
395 get_int_enum_int_ft(field
)->size
, value
),
396 "Value is out of bounds: value=%" PRId64
", %![field-]+f",
398 integer
->payload
.signd
= value
;
399 bt_field_set(field
, true);
403 int bt_field_integer_unsigned_get_value(struct bt_field
*field
, uint64_t *value
)
405 struct bt_field_common_integer
*integer
= (void *) field
;
407 BT_ASSERT_PRE_NON_NULL(field
, "Integer field");
408 BT_ASSERT_PRE_NON_NULL(value
, "Value");
409 BT_ASSERT_PRE_FIELD_COMMON_IS_SET(BT_TO_COMMON(integer
), "Integer field");
410 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer
), "Field");
411 BT_ASSERT_PRE(!bt_field_type_common_integer_is_signed(
412 BT_FROM_COMMON(get_int_enum_int_ft(field
))),
413 "Field's type is signed: %!+f", field
);
414 *value
= integer
->payload
.unsignd
;
418 int bt_field_integer_unsigned_set_value(struct bt_field
*field
,
421 struct bt_field_common_integer
*integer
= (void *) field
;
423 BT_ASSERT_PRE_NON_NULL(field
, "Integer field");
424 BT_ASSERT_PRE_FIELD_COMMON_HOT(BT_TO_COMMON(integer
), "Integer field");
425 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer
), "Field");
426 BT_ASSERT_PRE(!bt_field_type_common_integer_is_signed(
427 BT_FROM_COMMON(get_int_enum_int_ft(field
))),
428 "Field's type is signed: %!+f", field
);
429 BT_ASSERT_PRE(value_is_in_range_unsigned(
430 get_int_enum_int_ft(field
)->size
, value
),
431 "Value is out of bounds: value=%" PRIu64
", %![field-]+f",
433 integer
->payload
.unsignd
= value
;
434 bt_field_set(field
, true);
438 int bt_field_floating_point_get_value(struct bt_field
*field
,
441 return bt_field_common_floating_point_get_value((void *) field
, value
);
444 int bt_field_floating_point_set_value(struct bt_field
*field
,
447 return bt_field_common_floating_point_set_value((void *) field
, value
);
450 const char *bt_field_string_get_value(struct bt_field
*field
)
452 return bt_field_common_string_get_value((void *) field
);
455 int bt_field_string_set_value(struct bt_field
*field
, const char *value
)
457 return bt_field_common_string_set_value((void *) field
, value
);
460 int bt_field_string_append(struct bt_field
*field
, const char *value
)
462 return bt_field_common_string_append((void *) field
, value
);
465 int bt_field_string_append_len(struct bt_field
*field
,
466 const char *value
, unsigned int length
)
468 return bt_field_common_string_append_len((void *) field
, value
, length
);
471 int bt_field_string_clear(struct bt_field
*string_field
)
473 return bt_field_common_string_clear((void *) string_field
);
477 struct bt_field_common
*bt_field_common_copy(struct bt_field_common
*field
)
479 struct bt_field_common
*copy
= NULL
;
481 BT_ASSERT_PRE_NON_NULL(field
, "Field");
482 BT_ASSERT(field_type_common_has_known_id(field
->type
));
483 BT_ASSERT(field
->methods
->copy
);
484 copy
= field
->methods
->copy(field
);
486 BT_LOGW("Cannot create field: ft-addr=%p", field
->type
);
490 bt_field_common_set(copy
, field
->payload_set
);
497 void bt_field_integer_destroy(struct bt_field
*field
)
499 BT_LOGD("Destroying integer field object: addr=%p", field
);
500 bt_field_common_integer_finalize((void *) field
);
505 void bt_field_floating_point_destroy(struct bt_field
*field
)
507 BT_LOGD("Destroying floating point field object: addr=%p", field
);
508 bt_field_common_floating_point_finalize((void *) field
);
513 void bt_field_enumeration_destroy(struct bt_field
*field
)
515 BT_LOGD("Destroying enumeration field object: addr=%p", field
);
516 bt_field_common_finalize((void *) field
);
521 void bt_field_structure_destroy_recursive(struct bt_field
*field
)
523 BT_LOGD("Destroying structure field object: addr=%p", field
);
524 bt_field_common_structure_finalize_recursive((void *) field
);
529 void bt_field_variant_destroy_recursive(struct bt_field
*field
)
531 BT_LOGD("Destroying variant field object: addr=%p", field
);
532 bt_field_common_variant_finalize_recursive((void *) field
);
537 void bt_field_array_destroy_recursive(struct bt_field
*field
)
539 BT_LOGD("Destroying array field object: addr=%p", field
);
540 bt_field_common_array_finalize_recursive((void *) field
);
545 void bt_field_sequence_destroy_recursive(struct bt_field
*field
)
547 BT_LOGD("Destroying sequence field object: addr=%p", field
);
548 bt_field_common_sequence_finalize_recursive((void *) field
);
553 void bt_field_string_destroy(struct bt_field
*field
)
555 BT_LOGD("Destroying string field object: addr=%p", field
);
556 bt_field_common_string_finalize((void *) field
);
561 void bt_field_destroy_recursive(struct bt_field
*field
)
563 struct bt_field_common
*field_common
= (void *) field
;
569 BT_ASSERT(field_type_common_has_known_id((void *) field_common
->type
));
570 field_destroy_funcs
[field_common
->type
->id
](field
);
574 struct bt_field
*bt_field_integer_create(struct bt_field_type
*type
)
576 struct bt_field_common_integer
*integer
=
577 g_new0(struct bt_field_common_integer
, 1);
579 BT_LOGD("Creating integer field object: ft-addr=%p", type
);
582 bt_field_common_initialize(BT_TO_COMMON(integer
), (void *) type
,
583 false, NULL
, &bt_field_integer_methods
);
584 BT_LOGD("Created integer field object: addr=%p, ft-addr=%p",
587 BT_LOGE_STR("Failed to allocate one integer field.");
590 return (void *) integer
;
594 struct bt_field
*bt_field_enumeration_create(struct bt_field_type
*type
)
596 struct bt_field_enumeration
*enumeration
= g_new0(
597 struct bt_field_enumeration
, 1);
599 BT_LOGD("Creating enumeration field object: ft-addr=%p", type
);
602 bt_field_common_initialize(
603 BT_TO_COMMON(BT_TO_COMMON(enumeration
)),
604 (void *) type
, false, NULL
,
605 &bt_field_enumeration_methods
);
606 BT_LOGD("Created enumeration field object: addr=%p, ft-addr=%p",
609 BT_LOGE_STR("Failed to allocate one enumeration field.");
612 return (void *) enumeration
;
616 struct bt_field
*bt_field_floating_point_create(struct bt_field_type
*type
)
618 struct bt_field_common_floating_point
*floating_point
;
620 BT_LOGD("Creating floating point number field object: ft-addr=%p", type
);
621 floating_point
= g_new0(struct bt_field_common_floating_point
, 1);
623 if (floating_point
) {
624 bt_field_common_initialize(BT_TO_COMMON(floating_point
),
625 (void *) type
, false, NULL
,
626 &bt_field_floating_point_methods
);
627 BT_LOGD("Created floating point number field object: addr=%p, ft-addr=%p",
628 floating_point
, type
);
630 BT_LOGE_STR("Failed to allocate one floating point number field.");
633 return (void *) floating_point
;
637 int bt_field_common_structure_initialize(struct bt_field_common
*field
,
638 struct bt_field_type_common
*type
,
639 bool is_shared
, bt_object_release_func release_func
,
640 struct bt_field_common_methods
*methods
,
641 bt_field_common_create_func field_create_func
,
642 GDestroyNotify field_release_func
)
645 struct bt_field_type_common_structure
*structure_type
=
646 BT_FROM_COMMON(type
);
647 struct bt_field_common_structure
*structure
= BT_FROM_COMMON(field
);
650 BT_LOGD("Initializing common structure field object: ft-addr=%p", type
);
651 bt_field_common_initialize(field
, type
, is_shared
,
652 release_func
, methods
);
653 structure
->fields
= g_ptr_array_new_with_free_func(field_release_func
);
654 g_ptr_array_set_size(structure
->fields
, structure_type
->fields
->len
);
656 /* Create all fields contained in the structure field. */
657 for (i
= 0; i
< structure_type
->fields
->len
; i
++) {
658 struct bt_field_common
*field
;
659 struct bt_field_type_common_structure_field
*struct_field
=
660 BT_FIELD_TYPE_COMMON_STRUCTURE_FIELD_AT_INDEX(
662 field
= field_create_func(struct_field
->type
);
664 BT_LOGE("Failed to create structure field's member: name=\"%s\", index=%zu",
665 g_quark_to_string(struct_field
->name
), i
);
670 g_ptr_array_index(structure
->fields
, i
) = field
;
673 BT_LOGD("Initialized common structure field object: addr=%p, ft-addr=%p",
681 struct bt_field
*bt_field_structure_create(struct bt_field_type
*type
)
683 struct bt_field_common_structure
*structure
= g_new0(
684 struct bt_field_common_structure
, 1);
687 BT_LOGD("Creating structure field object: ft-addr=%p", type
);
690 BT_LOGE_STR("Failed to allocate one structure field.");
694 iret
= bt_field_common_structure_initialize(BT_TO_COMMON(structure
),
695 (void *) type
, false, NULL
, &bt_field_structure_methods
,
696 (bt_field_common_create_func
) bt_field_create_recursive
,
697 (GDestroyNotify
) bt_field_destroy_recursive
);
703 BT_LOGD("Created structure field object: addr=%p, ft-addr=%p",
707 return (void *) structure
;
711 int bt_field_common_variant_initialize(struct bt_field_common
*field
,
712 struct bt_field_type_common
*type
,
713 bool is_shared
, bt_object_release_func release_func
,
714 struct bt_field_common_methods
*methods
,
715 bt_field_common_create_func field_create_func
,
716 GDestroyNotify field_release_func
)
719 struct bt_field_type_common_variant
*variant_type
=
720 BT_FROM_COMMON(type
);
721 struct bt_field_common_variant
*variant
= BT_FROM_COMMON(field
);
724 BT_LOGD("Initializing common variant field object: ft-addr=%p", type
);
725 bt_field_common_initialize(field
, type
, is_shared
,
726 release_func
, methods
);
727 ret
= bt_field_type_common_variant_update_choices(type
);
729 BT_LOGE("Cannot update common variant field type choices: "
734 variant
->fields
= g_ptr_array_new_with_free_func(field_release_func
);
735 g_ptr_array_set_size(variant
->fields
, variant_type
->choices
->len
);
737 /* Create all fields contained in the variant field. */
738 for (i
= 0; i
< variant_type
->choices
->len
; i
++) {
739 struct bt_field_common
*field
;
740 struct bt_field_type_common_variant_choice
*var_choice
=
741 BT_FIELD_TYPE_COMMON_VARIANT_CHOICE_AT_INDEX(
744 field
= field_create_func(var_choice
->type
);
746 BT_LOGE("Failed to create variant field's member: name=\"%s\", index=%zu",
747 g_quark_to_string(var_choice
->name
), i
);
752 g_ptr_array_index(variant
->fields
, i
) = field
;
755 BT_LOGD("Initialized common variant field object: addr=%p, ft-addr=%p",
763 int bt_field_common_string_initialize(struct bt_field_common
*field
,
764 struct bt_field_type_common
*type
,
765 bool is_shared
, bt_object_release_func release_func
,
766 struct bt_field_common_methods
*methods
)
769 struct bt_field_common_string
*string
= BT_FROM_COMMON(field
);
771 BT_LOGD("Initializing common string field object: ft-addr=%p", type
);
772 bt_field_common_initialize(field
, type
, is_shared
,
773 release_func
, methods
);
774 string
->buf
= g_array_sized_new(FALSE
, FALSE
, sizeof(char), 1);
780 g_array_index(string
->buf
, char, 0) = '\0';
781 BT_LOGD("Initialized common string field object: addr=%p, ft-addr=%p",
789 struct bt_field
*bt_field_variant_create(struct bt_field_type
*type
)
791 struct bt_field_common_variant
*variant
= g_new0(
792 struct bt_field_common_variant
, 1);
795 BT_LOGD("Creating variant field object: ft-addr=%p", type
);
798 BT_LOGE_STR("Failed to allocate one variant field.");
802 iret
= bt_field_common_variant_initialize(BT_TO_COMMON(variant
),
803 (void *) type
, false, NULL
, &bt_field_variant_methods
,
804 (bt_field_common_create_func
) bt_field_create_recursive
,
805 (GDestroyNotify
) bt_field_destroy_recursive
);
811 BT_LOGD("Created variant field object: addr=%p, ft-addr=%p",
815 return (void *) variant
;
819 int bt_field_common_array_initialize(struct bt_field_common
*field
,
820 struct bt_field_type_common
*type
,
821 bool is_shared
, bt_object_release_func release_func
,
822 struct bt_field_common_methods
*methods
,
823 bt_field_common_create_func field_create_func
,
824 GDestroyNotify field_destroy_func
)
826 struct bt_field_type_common_array
*array_type
= BT_FROM_COMMON(type
);
827 struct bt_field_common_array
*array
= BT_FROM_COMMON(field
);
828 unsigned int array_length
;
832 BT_LOGD("Initializing common array field object: ft-addr=%p", type
);
834 bt_field_common_initialize(field
, type
, is_shared
,
835 release_func
, methods
);
836 array_length
= array_type
->length
;
837 array
->elements
= g_ptr_array_sized_new(array_length
);
838 if (!array
->elements
) {
843 g_ptr_array_set_free_func(array
->elements
, field_destroy_func
);
844 g_ptr_array_set_size(array
->elements
, array_length
);
846 for (i
= 0; i
< array_length
; i
++) {
847 array
->elements
->pdata
[i
] = field_create_func(
848 array_type
->element_ft
);
849 if (!array
->elements
->pdata
[i
]) {
855 BT_LOGD("Initialized common array field object: addr=%p, ft-addr=%p",
863 struct bt_field
*bt_field_array_create(struct bt_field_type
*type
)
865 struct bt_field_common_array
*array
=
866 g_new0(struct bt_field_common_array
, 1);
869 BT_LOGD("Creating array field object: ft-addr=%p", type
);
873 BT_LOGE_STR("Failed to allocate one array field.");
877 ret
= bt_field_common_array_initialize(BT_TO_COMMON(array
),
878 (void *) type
, false, NULL
, &bt_field_array_methods
,
879 (bt_field_common_create_func
) bt_field_create_recursive
,
880 (GDestroyNotify
) bt_field_destroy_recursive
);
886 BT_LOGD("Created array field object: addr=%p, ft-addr=%p",
890 return (void *) array
;
894 int bt_field_common_sequence_initialize(struct bt_field_common
*field
,
895 struct bt_field_type_common
*type
,
896 bool is_shared
, bt_object_release_func release_func
,
897 struct bt_field_common_methods
*methods
,
898 GDestroyNotify field_destroy_func
)
900 struct bt_field_common_sequence
*sequence
= BT_FROM_COMMON(field
);
903 BT_LOGD("Initializing common sequence field object: ft-addr=%p", type
);
905 bt_field_common_initialize(field
, type
, is_shared
,
906 release_func
, methods
);
907 sequence
->elements
= g_ptr_array_new();
908 if (!sequence
->elements
) {
913 g_ptr_array_set_free_func(sequence
->elements
, field_destroy_func
);
914 BT_LOGD("Initialized common sequence field object: addr=%p, ft-addr=%p",
922 struct bt_field
*bt_field_sequence_create(struct bt_field_type
*type
)
924 struct bt_field_common_sequence
*sequence
=
925 g_new0(struct bt_field_common_sequence
, 1);
928 BT_LOGD("Creating sequence field object: ft-addr=%p", type
);
932 BT_LOGE_STR("Failed to allocate one sequence field.");
936 ret
= bt_field_common_sequence_initialize(BT_TO_COMMON(sequence
),
937 (void *) type
, false, NULL
, &bt_field_sequence_methods
,
938 (GDestroyNotify
) bt_field_destroy_recursive
);
944 BT_LOGD("Created sequence field object: addr=%p, ft-addr=%p",
948 return (void *) sequence
;
952 struct bt_field
*bt_field_string_create(struct bt_field_type
*type
)
954 struct bt_field_common_string
*string
= g_new0(
955 struct bt_field_common_string
, 1);
957 BT_LOGD("Creating string field object: ft-addr=%p", type
);
960 bt_field_common_string_initialize(BT_TO_COMMON(string
),
961 (void *) type
, false, NULL
, &bt_field_string_methods
);
962 BT_LOGD("Created string field object: addr=%p, ft-addr=%p",
965 BT_LOGE_STR("Failed to allocate one string field.");
968 return (void *) string
;
972 int bt_field_common_generic_validate(struct bt_field_common
*field
)
974 return (field
&& field
->payload_set
) ? 0 : -1;
978 int bt_field_common_structure_validate_recursive(struct bt_field_common
*field
)
982 struct bt_field_common_structure
*structure
= BT_FROM_COMMON(field
);
986 for (i
= 0; i
< structure
->fields
->len
; i
++) {
987 ret
= bt_field_common_validate_recursive(
988 (void *) structure
->fields
->pdata
[i
]);
994 this_ret
= bt_field_type_common_structure_borrow_field_by_index(
995 field
->type
, &name
, NULL
, i
);
996 BT_ASSERT(this_ret
== 0);
997 BT_ASSERT_PRE_MSG("Invalid structure field's field: "
998 "%![struct-field-]+_f, field-name=\"%s\", "
999 "index=%" PRId64
", %![field-]+_f",
1000 field
, name
, i
, structure
->fields
->pdata
[i
]);
1010 int bt_field_common_variant_validate_recursive(struct bt_field_common
*field
)
1013 struct bt_field_common_variant
*variant
= BT_FROM_COMMON(field
);
1017 if (!variant
->current_field
) {
1022 ret
= bt_field_common_validate_recursive(variant
->current_field
);
1029 int bt_field_common_array_validate_recursive(struct bt_field_common
*field
)
1033 struct bt_field_common_array
*array
= BT_FROM_COMMON(field
);
1037 for (i
= 0; i
< array
->elements
->len
; i
++) {
1038 ret
= bt_field_common_validate_recursive((void *) array
->elements
->pdata
[i
]);
1040 BT_ASSERT_PRE_MSG("Invalid array field's element field: "
1041 "%![array-field-]+_f, " PRId64
", "
1042 "%![elem-field-]+_f",
1043 field
, i
, array
->elements
->pdata
[i
]);
1053 int bt_field_common_sequence_validate_recursive(struct bt_field_common
*field
)
1057 struct bt_field_common_sequence
*sequence
= BT_FROM_COMMON(field
);
1061 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
1062 ret
= bt_field_common_validate_recursive(
1063 (void *) sequence
->elements
->pdata
[i
]);
1065 BT_ASSERT_PRE_MSG("Invalid sequence field's element field: "
1066 "%![seq-field-]+_f, " PRId64
", "
1067 "%![elem-field-]+_f",
1068 field
, i
, sequence
->elements
->pdata
[i
]);
1077 void bt_field_common_generic_reset(struct bt_field_common
*field
)
1080 field
->payload_set
= false;
1084 void bt_field_common_structure_reset_recursive(struct bt_field_common
*field
)
1087 struct bt_field_common_structure
*structure
= BT_FROM_COMMON(field
);
1091 for (i
= 0; i
< structure
->fields
->len
; i
++) {
1092 struct bt_field_common
*member
= structure
->fields
->pdata
[i
];
1096 * Structure members are lazily initialized;
1097 * skip if this member has not been allocated
1103 bt_field_common_reset_recursive(member
);
1108 void bt_field_common_variant_reset_recursive(struct bt_field_common
*field
)
1110 struct bt_field_common_variant
*variant
= BT_FROM_COMMON(field
);
1113 variant
->current_field
= NULL
;
1117 void bt_field_common_array_reset_recursive(struct bt_field_common
*field
)
1120 struct bt_field_common_array
*array
= BT_FROM_COMMON(field
);
1124 for (i
= 0; i
< array
->elements
->len
; i
++) {
1125 struct bt_field_common
*member
= array
->elements
->pdata
[i
];
1129 * Array elements are lazily initialized; skip
1130 * if this member has not been allocated yet.
1135 bt_field_common_reset_recursive(member
);
1140 void bt_field_common_sequence_reset_recursive(struct bt_field_common
*field
)
1142 struct bt_field_common_sequence
*sequence
= BT_FROM_COMMON(field
);
1147 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
1148 if (sequence
->elements
->pdata
[i
]) {
1149 bt_field_common_reset_recursive(
1150 sequence
->elements
->pdata
[i
]);
1154 sequence
->length
= 0;
1158 void bt_field_common_generic_set_is_frozen(struct bt_field_common
*field
,
1161 field
->frozen
= is_frozen
;
1165 void bt_field_common_structure_set_is_frozen_recursive(
1166 struct bt_field_common
*field
, bool is_frozen
)
1169 struct bt_field_common_structure
*structure_field
=
1170 BT_FROM_COMMON(field
);
1172 BT_LOGD("Freezing structure field object: addr=%p", field
);
1174 for (i
= 0; i
< structure_field
->fields
->len
; i
++) {
1175 struct bt_field_common
*struct_field
=
1176 g_ptr_array_index(structure_field
->fields
, i
);
1178 BT_LOGD("Freezing structure field's field: field-addr=%p, index=%" PRId64
,
1180 bt_field_common_set_is_frozen_recursive(struct_field
,
1184 bt_field_common_generic_set_is_frozen(field
, is_frozen
);
1188 void bt_field_common_variant_set_is_frozen_recursive(
1189 struct bt_field_common
*field
, bool is_frozen
)
1192 struct bt_field_common_variant
*variant_field
= BT_FROM_COMMON(field
);
1194 BT_LOGD("Freezing variant field object: addr=%p", field
);
1196 for (i
= 0; i
< variant_field
->fields
->len
; i
++) {
1197 struct bt_field_common
*var_field
=
1198 g_ptr_array_index(variant_field
->fields
, i
);
1200 BT_LOGD("Freezing variant field's field: field-addr=%p, index=%" PRId64
,
1202 bt_field_common_set_is_frozen_recursive(var_field
, is_frozen
);
1205 bt_field_common_generic_set_is_frozen(field
, is_frozen
);
1209 void bt_field_common_array_set_is_frozen_recursive(
1210 struct bt_field_common
*field
, bool is_frozen
)
1213 struct bt_field_common_array
*array_field
= BT_FROM_COMMON(field
);
1215 BT_LOGD("Freezing array field object: addr=%p", field
);
1217 for (i
= 0; i
< array_field
->elements
->len
; i
++) {
1218 struct bt_field_common
*elem_field
=
1219 g_ptr_array_index(array_field
->elements
, i
);
1221 BT_LOGD("Freezing array field object's element field: "
1222 "element-field-addr=%p, index=%" PRId64
,
1224 bt_field_common_set_is_frozen_recursive(elem_field
, is_frozen
);
1227 bt_field_common_generic_set_is_frozen(field
, is_frozen
);
1231 void bt_field_common_sequence_set_is_frozen_recursive(
1232 struct bt_field_common
*field
, bool is_frozen
)
1235 struct bt_field_common_sequence
*sequence_field
=
1236 BT_FROM_COMMON(field
);
1238 BT_LOGD("Freezing sequence field object: addr=%p", field
);
1240 for (i
= 0; i
< sequence_field
->length
; i
++) {
1241 struct bt_field_common
*elem_field
=
1242 g_ptr_array_index(sequence_field
->elements
, i
);
1244 BT_LOGD("Freezing sequence field object's element field: "
1245 "element-field-addr=%p, index=%" PRId64
,
1247 bt_field_common_set_is_frozen_recursive(elem_field
, is_frozen
);
1250 bt_field_common_generic_set_is_frozen(field
, is_frozen
);
1254 void _bt_field_common_set_is_frozen_recursive(struct bt_field_common
*field
,
1261 if (field
->frozen
) {
1265 BT_LOGD("Setting field object's frozen state: addr=%p, is-frozen=%d",
1267 BT_ASSERT(field_type_common_has_known_id(field
->type
));
1268 BT_ASSERT(field
->methods
->set_is_frozen
);
1269 field
->methods
->set_is_frozen(field
, is_frozen
);
1276 bt_bool
bt_field_common_generic_is_set(struct bt_field_common
*field
)
1278 return field
&& field
->payload_set
;
1282 bt_bool
bt_field_common_structure_is_set_recursive(
1283 struct bt_field_common
*field
)
1285 bt_bool is_set
= BT_FALSE
;
1287 struct bt_field_common_structure
*structure
= BT_FROM_COMMON(field
);
1291 for (i
= 0; i
< structure
->fields
->len
; i
++) {
1292 is_set
= bt_field_common_is_set_recursive(
1293 structure
->fields
->pdata
[i
]);
1304 bt_bool
bt_field_common_variant_is_set_recursive(struct bt_field_common
*field
)
1306 struct bt_field_common_variant
*variant
= BT_FROM_COMMON(field
);
1307 bt_bool is_set
= BT_FALSE
;
1311 if (variant
->current_field
) {
1312 is_set
= bt_field_common_is_set_recursive(
1313 variant
->current_field
);
1320 bt_bool
bt_field_common_array_is_set_recursive(struct bt_field_common
*field
)
1323 bt_bool is_set
= BT_FALSE
;
1324 struct bt_field_common_array
*array
= BT_FROM_COMMON(field
);
1328 for (i
= 0; i
< array
->elements
->len
; i
++) {
1329 is_set
= bt_field_common_is_set_recursive(array
->elements
->pdata
[i
]);
1340 bt_bool
bt_field_common_sequence_is_set_recursive(struct bt_field_common
*field
)
1343 bt_bool is_set
= BT_FALSE
;
1344 struct bt_field_common_sequence
*sequence
= BT_FROM_COMMON(field
);
1348 if (!sequence
->elements
) {
1352 for (i
= 0; i
< sequence
->elements
->len
; i
++) {
1353 is_set
= bt_field_common_is_set_recursive(
1354 sequence
->elements
->pdata
[i
]);