lib/ctf-ir/fields.c

   1 /*
   2  * fields.c
   3  *
   4  * Babeltrace CTF IR - Event Fields
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  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:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  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
  26  * SOFTWARE.
  27  */
  28
  29 #define BT_LOG_TAG "FIELDS"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  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>
  41 #include <inttypes.h>
  42
  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: "    \
  47                 "%!+f", (_field))
  48
  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,
  52         .copy = NULL,
  53         .is_set = bt_field_common_generic_is_set,
  54         .reset = bt_field_common_generic_reset,
  55 };
  56
  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,
  60         .copy = NULL,
  61         .is_set = bt_field_common_generic_is_set,
  62         .reset = bt_field_common_generic_reset,
  63 };
  64
  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,
  68         .copy = NULL,
  69         .is_set = bt_field_common_generic_is_set,
  70         .reset = bt_field_common_generic_reset,
  71 };
  72
  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,
  76         .copy = NULL,
  77         .is_set = bt_field_common_generic_is_set,
  78         .reset = bt_field_common_string_reset,
  79 };
  80
  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,
  84         .copy = NULL,
  85         .is_set = bt_field_common_structure_is_set_recursive,
  86         .reset = bt_field_common_structure_reset_recursive,
  87 };
  88
  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,
  92         .copy = NULL,
  93         .is_set = bt_field_common_sequence_is_set_recursive,
  94         .reset = bt_field_common_sequence_reset_recursive,
  95 };
  96
  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,
 100         .copy = NULL,
 101         .is_set = bt_field_common_array_is_set_recursive,
 102         .reset = bt_field_common_array_reset_recursive,
 103 };
 104
 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,
 108         .copy = NULL,
 109         .is_set = bt_field_common_variant_is_set_recursive,
 110         .reset = bt_field_common_variant_reset_recursive,
 111 };
 112
 113 static
 114 struct bt_field *bt_field_integer_create(struct bt_field_type *);
 115
 116 static
 117 struct bt_field *bt_field_enumeration_create(struct bt_field_type *);
 118
 119 static
 120 struct bt_field *bt_field_floating_point_create(struct bt_field_type *);
 121
 122 static
 123 struct bt_field *bt_field_structure_create(struct bt_field_type *);
 124
 125 static
 126 struct bt_field *bt_field_variant_create(struct bt_field_type *);
 127
 128 static
 129 struct bt_field *bt_field_array_create(struct bt_field_type *);
 130
 131 static
 132 struct bt_field *bt_field_sequence_create(struct bt_field_type *);
 133
 134 static
 135 struct bt_field *bt_field_string_create(struct bt_field_type *);
 136
 137 static
 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,
 147 };
 148
 149 static
 150 void bt_field_integer_destroy(struct bt_field *field);
 151
 152 static
 153 void bt_field_enumeration_destroy(struct bt_field *field);
 154
 155 static
 156 void bt_field_floating_point_destroy(struct bt_field *field);
 157
 158 static
 159 void bt_field_structure_destroy_recursive(struct bt_field *field);
 160
 161 static
 162 void bt_field_variant_destroy_recursive(struct bt_field *field);
 163
 164 static
 165 void bt_field_array_destroy_recursive(struct bt_field *field);
 166
 167 static
 168 void bt_field_sequence_destroy_recursive(struct bt_field *field);
 169
 170 static
 171 void bt_field_string_destroy(struct bt_field *field);
 172
 173 static
 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,
 183 };
 184
 185 BT_HIDDEN
 186 struct bt_field *bt_field_create_recursive(struct bt_field_type *type)
 187 {
 188         struct bt_field *field = NULL;
 189         enum bt_field_type_id type_id;
 190
 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);
 197         if (!field) {
 198                 goto end;
 199         }
 200
 201         bt_object_set_is_shared((void *) field, false);
 202         bt_field_type_freeze(type);
 203
 204 end:
 205         return field;
 206 }
 207
 208 struct bt_field_type *bt_field_borrow_type(struct bt_field *field)
 209 {
 210         return (void *) bt_field_common_borrow_type((void *) field);
 211 }
 212
 213 enum bt_field_type_id bt_field_get_type_id(struct bt_field *field)
 214 {
 215         struct bt_field_common *field_common = (void *) field;
 216
 217         BT_ASSERT_PRE_NON_NULL(field, "Field");
 218         return field_common->type->id;
 219 }
 220
 221 bt_bool bt_field_is_integer(struct bt_field *field)
 222 {
 223         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_INTEGER;
 224 }
 225
 226 bt_bool bt_field_is_floating_point(struct bt_field *field)
 227 {
 228         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_FLOAT;
 229 }
 230
 231 bt_bool bt_field_is_enumeration(struct bt_field *field)
 232 {
 233         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_ENUM;
 234 }
 235
 236 bt_bool bt_field_is_string(struct bt_field *field)
 237 {
 238         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_STRING;
 239 }
 240
 241 bt_bool bt_field_is_structure(struct bt_field *field)
 242 {
 243         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_STRUCT;
 244 }
 245
 246 bt_bool bt_field_is_array(struct bt_field *field)
 247 {
 248         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_ARRAY;
 249 }
 250
 251 bt_bool bt_field_is_sequence(struct bt_field *field)
 252 {
 253         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_SEQUENCE;
 254 }
 255
 256 bt_bool bt_field_is_variant(struct bt_field *field)
 257 {
 258         return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_VARIANT;
 259 }
 260
 261 int64_t bt_field_sequence_get_length(struct bt_field *field)
 262 {
 263         return bt_field_common_sequence_get_length((void *) field);
 264 }
 265
 266 int bt_field_sequence_set_length(struct bt_field *field, uint64_t length)
 267 {
 268         return bt_field_common_sequence_set_length((void *) field,
 269                 length, (bt_field_common_create_func) bt_field_create_recursive);
 270 }
 271
 272 struct bt_field *bt_field_structure_borrow_field_by_index(
 273                 struct bt_field *field, uint64_t index)
 274 {
 275         return (void *) bt_field_common_structure_borrow_field_by_index(
 276                 (void *) field, index);
 277 }
 278
 279 struct bt_field *bt_field_structure_borrow_field_by_name(
 280                 struct bt_field *field, const char *name)
 281 {
 282         return (void *) bt_field_common_structure_borrow_field_by_name(
 283                 (void *) field, name);
 284 }
 285
 286 struct bt_field *bt_field_array_borrow_field(
 287                 struct bt_field *field, uint64_t index)
 288 {
 289         return (void *) bt_field_common_array_borrow_field((void *) field,
 290                 index);
 291 }
 292
 293 struct bt_field *bt_field_sequence_borrow_field(
 294                 struct bt_field *field, uint64_t index)
 295 {
 296         return (void *) bt_field_common_sequence_borrow_field((void *) field,
 297                 index);
 298 }
 299
 300 struct bt_field *bt_field_variant_borrow_current_field(
 301                 struct bt_field *variant_field)
 302 {
 303         return (void *) bt_field_common_variant_borrow_current_field(
 304                 (void *) variant_field);
 305 }
 306
 307 int bt_field_variant_set_tag_signed(struct bt_field *variant_field,
 308                 int64_t tag)
 309 {
 310         return bt_field_variant_common_set_tag((void *) variant_field,
 311                 (uint64_t) tag, true);
 312 }
 313
 314 int bt_field_variant_set_tag_unsigned(struct bt_field *variant_field,
 315                 uint64_t tag)
 316 {
 317         return bt_field_variant_common_set_tag((void *) variant_field,
 318                 (uint64_t) tag, false);
 319 }
 320
 321 int bt_field_variant_get_tag_signed(struct bt_field *variant_field,
 322                 int64_t *tag)
 323 {
 324         return bt_field_common_variant_get_tag_signed((void *) variant_field, tag);
 325 }
 326
 327 int bt_field_variant_get_tag_unsigned(struct bt_field *variant_field,
 328                 uint64_t *tag)
 329 {
 330         return bt_field_common_variant_get_tag_unsigned((void *) variant_field, tag);
 331 }
 332
 333 struct bt_field_type_enumeration_mapping_iterator *
 334 bt_field_enumeration_get_mappings(struct bt_field *field)
 335 {
 336         struct bt_field_enumeration *enum_field = (void *) field;
 337
 338         BT_ASSERT_PRE_NON_NULL(field, "Enumeration field");
 339         BT_ASSERT_PRE_FIELD_COMMON_HAS_TYPE_ID((struct bt_field_common *) field,
 340                 BT_FIELD_TYPE_ID_ENUM, "Field");
 341         BT_ASSERT_PRE_FIELD_COMMON_IS_SET((struct bt_field_common *) field,
 342                 "Enumeration field");
 343         return bt_field_common_enumeration_get_mappings((void *) field,
 344                 (bt_field_common_create_func) bt_field_create_recursive,
 345                 enum_field->common.payload.unsignd);
 346 }
 347
 348 BT_ASSERT_PRE_FUNC
 349 static inline
 350 struct bt_field_type_common_integer *get_int_enum_int_ft(
 351                 struct bt_field *field)
 352 {
 353         struct bt_field_common_integer *int_field = (void *) field;
 354         struct bt_field_type_common_integer *int_ft = NULL;
 355
 356         if (int_field->common.type->id == BT_FIELD_TYPE_ID_INTEGER) {
 357                 int_ft = BT_FROM_COMMON(int_field->common.type);
 358         } else if (int_field->common.type->id == BT_FIELD_TYPE_ID_ENUM) {
 359                 struct bt_field_type_common_enumeration *enum_ft =
 360                         BT_FROM_COMMON(int_field->common.type);
 361                 int_ft = enum_ft->container_ft;
 362         }
 363
 364         BT_ASSERT(int_ft);
 365         return int_ft;
 366 }
 367
 368 int bt_field_integer_signed_get_value(struct bt_field *field, int64_t *value)
 369 {
 370         struct bt_field_common_integer *integer = (void *) field;
 371
 372         BT_ASSERT_PRE_NON_NULL(field, "Integer/enumeration field");
 373         BT_ASSERT_PRE_NON_NULL(value, "Value");
 374         BT_ASSERT_PRE_FIELD_COMMON_IS_SET(BT_TO_COMMON(integer),
 375                 "Integer/enumeration field");
 376         BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
 377         BT_ASSERT_PRE(bt_field_type_common_integer_is_signed(
 378                 BT_TO_COMMON(get_int_enum_int_ft(field))),
 379                 "Field's type is unsigned: %!+f", field);
 380         *value = integer->payload.signd;
 381         return 0;
 382 }
 383
 384 int bt_field_integer_signed_set_value(struct bt_field *field, int64_t value)
 385 {
 386         int ret = 0;
 387         struct bt_field_common_integer *integer = (void *) field;
 388
 389         BT_ASSERT_PRE_NON_NULL(field, "Integer field");
 390         BT_ASSERT_PRE_FIELD_COMMON_HOT(BT_TO_COMMON(integer), "Integer field");
 391         BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
 392         BT_ASSERT_PRE(bt_field_type_common_integer_is_signed(
 393                 BT_FROM_COMMON(get_int_enum_int_ft(field))),
 394                 "Field's type is unsigned: %!+f", field);
 395         BT_ASSERT_PRE(value_is_in_range_signed(
 396                 get_int_enum_int_ft(field)->size, value),
 397                 "Value is out of bounds: value=%" PRId64 ", %![field-]+f",
 398                 value, field);
 399         integer->payload.signd = value;
 400         bt_field_set(field, true);
 401         return ret;
 402 }
 403
 404 int bt_field_integer_unsigned_get_value(struct bt_field *field, uint64_t *value)
 405 {
 406         struct bt_field_common_integer *integer = (void *) field;
 407
 408         BT_ASSERT_PRE_NON_NULL(field, "Integer field");
 409         BT_ASSERT_PRE_NON_NULL(value, "Value");
 410         BT_ASSERT_PRE_FIELD_COMMON_IS_SET(BT_TO_COMMON(integer), "Integer field");
 411         BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
 412         BT_ASSERT_PRE(!bt_field_type_common_integer_is_signed(
 413                 BT_FROM_COMMON(get_int_enum_int_ft(field))),
 414                 "Field's type is signed: %!+f", field);
 415         *value = integer->payload.unsignd;
 416         return 0;
 417 }
 418
 419 int bt_field_integer_unsigned_set_value(struct bt_field *field,
 420                 uint64_t value)
 421 {
 422         struct bt_field_common_integer *integer = (void *) field;
 423
 424         BT_ASSERT_PRE_NON_NULL(field, "Integer field");
 425         BT_ASSERT_PRE_FIELD_COMMON_HOT(BT_TO_COMMON(integer), "Integer field");
 426         BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
 427         BT_ASSERT_PRE(!bt_field_type_common_integer_is_signed(
 428                 BT_FROM_COMMON(get_int_enum_int_ft(field))),
 429                 "Field's type is signed: %!+f", field);
 430         BT_ASSERT_PRE(value_is_in_range_unsigned(
 431                 get_int_enum_int_ft(field)->size, value),
 432                 "Value is out of bounds: value=%" PRIu64 ", %![field-]+f",
 433                 value, field);
 434         integer->payload.unsignd = value;
 435         bt_field_set(field, true);
 436         return 0;
 437 }
 438
 439 int bt_field_floating_point_get_value(struct bt_field *field,
 440                 double *value)
 441 {
 442         return bt_field_common_floating_point_get_value((void *) field, value);
 443 }
 444
 445 int bt_field_floating_point_set_value(struct bt_field *field,
 446                 double value)
 447 {
 448         return bt_field_common_floating_point_set_value((void *) field, value);
 449 }
 450
 451 const char *bt_field_string_get_value(struct bt_field *field)
 452 {
 453         return bt_field_common_string_get_value((void *) field);
 454 }
 455
 456 int bt_field_string_set_value(struct bt_field *field, const char *value)
 457 {
 458         return bt_field_common_string_set_value((void *) field, value);
 459 }
 460
 461 int bt_field_string_append(struct bt_field *field, const char *value)
 462 {
 463         return bt_field_common_string_append((void *) field, value);
 464 }
 465
 466 int bt_field_string_append_len(struct bt_field *field,
 467                 const char *value, unsigned int length)
 468 {
 469         return bt_field_common_string_append_len((void *) field, value, length);
 470 }
 471
 472 int bt_field_string_clear(struct bt_field *string_field)
 473 {
 474         return bt_field_common_string_clear((void *) string_field);
 475 }
 476
 477 BT_HIDDEN
 478 struct bt_field_common *bt_field_common_copy(struct bt_field_common *field)
 479 {
 480         struct bt_field_common *copy = NULL;
 481
 482         BT_ASSERT_PRE_NON_NULL(field, "Field");
 483         BT_ASSERT(field_type_common_has_known_id(field->type));
 484         BT_ASSERT(field->methods->copy);
 485         copy = field->methods->copy(field);
 486         if (!copy) {
 487                 BT_LOGW("Cannot create field: ft-addr=%p", field->type);
 488                 goto end;
 489         }
 490
 491         bt_field_common_set(copy, field->payload_set);
 492
 493 end:
 494         return copy;
 495 }
 496
 497 static
 498 void bt_field_integer_destroy(struct bt_field *field)
 499 {
 500         BT_LOGD("Destroying integer field object: addr=%p", field);
 501         bt_field_common_integer_finalize((void *) field);
 502         g_free(field);
 503 }
 504
 505 static
 506 void bt_field_floating_point_destroy(struct bt_field *field)
 507 {
 508         BT_LOGD("Destroying floating point field object: addr=%p", field);
 509         bt_field_common_floating_point_finalize((void *) field);
 510         g_free(field);
 511 }
 512
 513 static
 514 void bt_field_enumeration_destroy(struct bt_field *field)
 515 {
 516         BT_LOGD("Destroying enumeration field object: addr=%p", field);
 517         bt_field_common_finalize((void *) field);
 518         g_free(field);
 519 }
 520
 521 static
 522 void bt_field_structure_destroy_recursive(struct bt_field *field)
 523 {
 524         BT_LOGD("Destroying structure field object: addr=%p", field);
 525         bt_field_common_structure_finalize_recursive((void *) field);
 526         g_free(field);
 527 }
 528
 529 static
 530 void bt_field_variant_destroy_recursive(struct bt_field *field)
 531 {
 532         BT_LOGD("Destroying variant field object: addr=%p", field);
 533         bt_field_common_variant_finalize_recursive((void *) field);
 534         g_free(field);
 535 }
 536
 537 static
 538 void bt_field_array_destroy_recursive(struct bt_field *field)
 539 {
 540         BT_LOGD("Destroying array field object: addr=%p", field);
 541         bt_field_common_array_finalize_recursive((void *) field);
 542         g_free(field);
 543 }
 544
 545 static
 546 void bt_field_sequence_destroy_recursive(struct bt_field *field)
 547 {
 548         BT_LOGD("Destroying sequence field object: addr=%p", field);
 549         bt_field_common_sequence_finalize_recursive((void *) field);
 550         g_free(field);
 551 }
 552
 553 static
 554 void bt_field_string_destroy(struct bt_field *field)
 555 {
 556         BT_LOGD("Destroying string field object: addr=%p", field);
 557         bt_field_common_string_finalize((void *) field);
 558         g_free(field);
 559 }
 560
 561 BT_HIDDEN
 562 void bt_field_destroy_recursive(struct bt_field *field)
 563 {
 564         struct bt_field_common *field_common = (void *) field;
 565
 566         if (!field) {
 567                 return;
 568         }
 569
 570         BT_ASSERT(field_type_common_has_known_id((void *) field_common->type));
 571         field_destroy_funcs[field_common->type->id](field);
 572 }
 573
 574 static
 575 struct bt_field *bt_field_integer_create(struct bt_field_type *type)
 576 {
 577         struct bt_field_common_integer *integer =
 578                 g_new0(struct bt_field_common_integer, 1);
 579
 580         BT_LOGD("Creating integer field object: ft-addr=%p", type);
 581
 582         if (integer) {
 583                 bt_field_common_initialize(BT_TO_COMMON(integer), (void *) type,
 584                         NULL, &bt_field_integer_methods);
 585                 BT_LOGD("Created integer field object: addr=%p, ft-addr=%p",
 586                         integer, type);
 587         } else {
 588                 BT_LOGE_STR("Failed to allocate one integer field.");
 589         }
 590
 591         return (void *) integer;
 592 }
 593
 594 static
 595 struct bt_field *bt_field_enumeration_create(struct bt_field_type *type)
 596 {
 597         struct bt_field_enumeration *enumeration = g_new0(
 598                 struct bt_field_enumeration, 1);
 599
 600         BT_LOGD("Creating enumeration field object: ft-addr=%p", type);
 601
 602         if (enumeration) {
 603                 bt_field_common_initialize(
 604                         BT_TO_COMMON(BT_TO_COMMON(enumeration)),
 605                         (void *) type, NULL, &bt_field_enumeration_methods);
 606                 BT_LOGD("Created enumeration field object: addr=%p, ft-addr=%p",
 607                         enumeration, type);
 608         } else {
 609                 BT_LOGE_STR("Failed to allocate one enumeration field.");
 610         }
 611
 612         return (void *) enumeration;
 613 }
 614
 615 static
 616 struct bt_field *bt_field_floating_point_create(struct bt_field_type *type)
 617 {
 618         struct bt_field_common_floating_point *floating_point;
 619
 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);
 622
 623         if (floating_point) {
 624                 bt_field_common_initialize(BT_TO_COMMON(floating_point),
 625                         (void *) type, NULL, &bt_field_floating_point_methods);
 626                 BT_LOGD("Created floating point number field object: addr=%p, ft-addr=%p",
 627                         floating_point, type);
 628         } else {
 629                 BT_LOGE_STR("Failed to allocate one floating point number field.");
 630         }
 631
 632         return (void *) floating_point;
 633 }
 634
 635 BT_HIDDEN
 636 int bt_field_common_structure_initialize(struct bt_field_common *field,
 637                 struct bt_field_type_common *type,
 638                 bt_object_release_func release_func,
 639                 struct bt_field_common_methods *methods,
 640                 bt_field_common_create_func field_create_func,
 641                 GDestroyNotify field_release_func)
 642 {
 643         int ret = 0;
 644         struct bt_field_type_common_structure *structure_type =
 645                 BT_FROM_COMMON(type);
 646         struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
 647         size_t i;
 648
 649         BT_LOGD("Initializing common structure field object: ft-addr=%p", type);
 650         bt_field_common_initialize(field, type, release_func, methods);
 651         structure->fields = g_ptr_array_new_with_free_func(field_release_func);
 652         g_ptr_array_set_size(structure->fields, structure_type->fields->len);
 653
 654         /* Create all fields contained in the structure field. */
 655         for (i = 0; i < structure_type->fields->len; i++) {
 656                 struct bt_field_common *field;
 657                 struct bt_field_type_common_structure_field *struct_field =
 658                         BT_FIELD_TYPE_COMMON_STRUCTURE_FIELD_AT_INDEX(
 659                                 structure_type, i);
 660                 field = field_create_func(struct_field->type);
 661                 if (!field) {
 662                         BT_LOGE("Failed to create structure field's member: name=\"%s\", index=%zu",
 663                                 g_quark_to_string(struct_field->name), i);
 664                         ret = -1;
 665                         goto end;
 666                 }
 667
 668                 g_ptr_array_index(structure->fields, i) = field;
 669         }
 670
 671         BT_LOGD("Initialized common structure field object: addr=%p, ft-addr=%p",
 672                 field, type);
 673
 674 end:
 675         return ret;
 676 }
 677
 678 static
 679 struct bt_field *bt_field_structure_create(struct bt_field_type *type)
 680 {
 681         struct bt_field_common_structure *structure = g_new0(
 682                 struct bt_field_common_structure, 1);
 683         int iret;
 684
 685         BT_LOGD("Creating structure field object: ft-addr=%p", type);
 686
 687         if (!structure) {
 688                 BT_LOGE_STR("Failed to allocate one structure field.");
 689                 goto end;
 690         }
 691
 692         iret = bt_field_common_structure_initialize(BT_TO_COMMON(structure),
 693                 (void *) type, NULL, &bt_field_structure_methods,
 694                 (bt_field_common_create_func) bt_field_create_recursive,
 695                 (GDestroyNotify) bt_field_destroy_recursive);
 696         if (iret) {
 697                 BT_PUT(structure);
 698                 goto end;
 699         }
 700
 701         BT_LOGD("Created structure field object: addr=%p, ft-addr=%p",
 702                 structure, type);
 703
 704 end:
 705         return (void *) structure;
 706 }
 707
 708 BT_HIDDEN
 709 int bt_field_common_variant_initialize(struct bt_field_common *field,
 710                 struct bt_field_type_common *type,
 711                 bt_object_release_func release_func,
 712                 struct bt_field_common_methods *methods,
 713                 bt_field_common_create_func field_create_func,
 714                 GDestroyNotify field_release_func)
 715 {
 716         int ret = 0;
 717         struct bt_field_type_common_variant *variant_type =
 718                 BT_FROM_COMMON(type);
 719         struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
 720         size_t i;
 721
 722         BT_LOGD("Initializing common variant field object: ft-addr=%p", type);
 723         bt_field_common_initialize(field, type, release_func, methods);
 724         ret = bt_field_type_common_variant_update_choices(type);
 725         if (ret) {
 726                 BT_LOGE("Cannot update common variant field type choices: "
 727                         "ret=%d", ret);
 728                 goto end;
 729         }
 730
 731         variant->fields = g_ptr_array_new_with_free_func(field_release_func);
 732         g_ptr_array_set_size(variant->fields, variant_type->choices->len);
 733
 734         /* Create all fields contained in the variant field. */
 735         for (i = 0; i < variant_type->choices->len; i++) {
 736                 struct bt_field_common *field;
 737                 struct bt_field_type_common_variant_choice *var_choice =
 738                         BT_FIELD_TYPE_COMMON_VARIANT_CHOICE_AT_INDEX(
 739                                 variant_type, i);
 740
 741                 field = field_create_func(var_choice->type);
 742                 if (!field) {
 743                         BT_LOGE("Failed to create variant field's member: name=\"%s\", index=%zu",
 744                                 g_quark_to_string(var_choice->name), i);
 745                         ret = -1;
 746                         goto end;
 747                 }
 748
 749                 g_ptr_array_index(variant->fields, i) = field;
 750         }
 751
 752         BT_LOGD("Initialized common variant field object: addr=%p, ft-addr=%p",
 753                 field, type);
 754
 755 end:
 756         return ret;
 757 }
 758
 759 static
 760 struct bt_field *bt_field_variant_create(struct bt_field_type *type)
 761 {
 762         struct bt_field_common_variant *variant = g_new0(
 763                 struct bt_field_common_variant, 1);
 764         int iret;
 765
 766         BT_LOGD("Creating variant field object: ft-addr=%p", type);
 767
 768         if (!variant) {
 769                 BT_LOGE_STR("Failed to allocate one variant field.");
 770                 goto end;
 771         }
 772
 773         iret = bt_field_common_variant_initialize(BT_TO_COMMON(variant),
 774                 (void *) type, NULL, &bt_field_variant_methods,
 775                 (bt_field_common_create_func) bt_field_create_recursive,
 776                 (GDestroyNotify) bt_field_destroy_recursive);
 777         if (iret) {
 778                 BT_PUT(variant);
 779                 goto end;
 780         }
 781
 782         BT_LOGD("Created variant field object: addr=%p, ft-addr=%p",
 783                 variant, type);
 784
 785 end:
 786         return (void *) variant;
 787 }
 788
 789 BT_HIDDEN
 790 int bt_field_common_array_initialize(struct bt_field_common *field,
 791                 struct bt_field_type_common *type,
 792                 bt_object_release_func release_func,
 793                 struct bt_field_common_methods *methods,
 794                 bt_field_common_create_func field_create_func,
 795                 GDestroyNotify field_destroy_func)
 796 {
 797         struct bt_field_type_common_array *array_type = BT_FROM_COMMON(type);
 798         struct bt_field_common_array *array = BT_FROM_COMMON(field);
 799         unsigned int array_length;
 800         int ret = 0;
 801         uint64_t i;
 802
 803         BT_LOGD("Initializing common array field object: ft-addr=%p", type);
 804         BT_ASSERT(type);
 805         bt_field_common_initialize(field, type, release_func, methods);
 806         array_length = array_type->length;
 807         array->elements = g_ptr_array_sized_new(array_length);
 808         if (!array->elements) {
 809                 ret = -1;
 810                 goto end;
 811         }
 812
 813         g_ptr_array_set_free_func(array->elements, field_destroy_func);
 814         g_ptr_array_set_size(array->elements, array_length);
 815
 816         for (i = 0; i < array_length; i++) {
 817                 array->elements->pdata[i] = field_create_func(
 818                         array_type->element_ft);
 819                 if (!array->elements->pdata[i]) {
 820                         ret = -1;
 821                         goto end;
 822                 }
 823         }
 824
 825         BT_LOGD("Initialized common array field object: addr=%p, ft-addr=%p",
 826                 field, type);
 827
 828 end:
 829         return ret;
 830 }
 831
 832 static
 833 struct bt_field *bt_field_array_create(struct bt_field_type *type)
 834 {
 835         struct bt_field_common_array *array =
 836                 g_new0(struct bt_field_common_array, 1);
 837         int ret;
 838
 839         BT_LOGD("Creating array field object: ft-addr=%p", type);
 840         BT_ASSERT(type);
 841
 842         if (!array) {
 843                 BT_LOGE_STR("Failed to allocate one array field.");
 844                 goto end;
 845         }
 846
 847         ret = bt_field_common_array_initialize(BT_TO_COMMON(array),
 848                 (void *) type, NULL, &bt_field_array_methods,
 849                 (bt_field_common_create_func) bt_field_create_recursive,
 850                 (GDestroyNotify) bt_field_destroy_recursive);
 851         if (ret) {
 852                 BT_PUT(array);
 853                 goto end;
 854         }
 855
 856         BT_LOGD("Created array field object: addr=%p, ft-addr=%p",
 857                 array, type);
 858
 859 end:
 860         return (void *) array;
 861 }
 862
 863 BT_HIDDEN
 864 int bt_field_common_sequence_initialize(struct bt_field_common *field,
 865                 struct bt_field_type_common *type,
 866                 bt_object_release_func release_func,
 867                 struct bt_field_common_methods *methods,
 868                 GDestroyNotify field_destroy_func)
 869 {
 870         struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
 871         int ret = 0;
 872
 873         BT_LOGD("Initializing common sequence field object: ft-addr=%p", type);
 874         BT_ASSERT(type);
 875         bt_field_common_initialize(field, type, release_func, methods);
 876         sequence->elements = g_ptr_array_new();
 877         if (!sequence->elements) {
 878                 ret = -1;
 879                 goto end;
 880         }
 881
 882         g_ptr_array_set_free_func(sequence->elements, field_destroy_func);
 883         BT_LOGD("Initialized common sequence field object: addr=%p, ft-addr=%p",
 884                 field, type);
 885
 886 end:
 887         return ret;
 888 }
 889
 890 static
 891 struct bt_field *bt_field_sequence_create(struct bt_field_type *type)
 892 {
 893         struct bt_field_common_sequence *sequence =
 894                 g_new0(struct bt_field_common_sequence, 1);
 895         int ret;
 896
 897         BT_LOGD("Creating sequence field object: ft-addr=%p", type);
 898         BT_ASSERT(type);
 899
 900         if (!sequence) {
 901                 BT_LOGE_STR("Failed to allocate one sequence field.");
 902                 goto end;
 903         }
 904
 905         ret = bt_field_common_sequence_initialize(BT_TO_COMMON(sequence),
 906                 (void *) type, NULL, &bt_field_sequence_methods,
 907                 (GDestroyNotify) bt_field_destroy_recursive);
 908         if (ret) {
 909                 BT_PUT(sequence);
 910                 goto end;
 911         }
 912
 913         BT_LOGD("Created sequence field object: addr=%p, ft-addr=%p",
 914                 sequence, type);
 915
 916 end:
 917         return (void *) sequence;
 918 }
 919
 920 static
 921 struct bt_field *bt_field_string_create(struct bt_field_type *type)
 922 {
 923         struct bt_field_common_string *string = g_new0(
 924                 struct bt_field_common_string, 1);
 925
 926         BT_LOGD("Creating string field object: ft-addr=%p", type);
 927
 928         if (string) {
 929                 bt_field_common_initialize(BT_TO_COMMON(string),
 930                         (void *) type, NULL, &bt_field_string_methods);
 931                 BT_LOGD("Created string field object: addr=%p, ft-addr=%p",
 932                         string, type);
 933         } else {
 934                 BT_LOGE_STR("Failed to allocate one string field.");
 935         }
 936
 937         return (void *) string;
 938 }
 939
 940 BT_HIDDEN
 941 int bt_field_common_generic_validate(struct bt_field_common *field)
 942 {
 943         return (field && field->payload_set) ? 0 : -1;
 944 }
 945
 946 BT_HIDDEN
 947 int bt_field_common_structure_validate_recursive(struct bt_field_common *field)
 948 {
 949         int64_t i;
 950         int ret = 0;
 951         struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
 952
 953         BT_ASSERT(field);
 954
 955         for (i = 0; i < structure->fields->len; i++) {
 956                 ret = bt_field_common_validate_recursive(
 957                         (void *) structure->fields->pdata[i]);
 958
 959                 if (ret) {
 960                         int this_ret;
 961                         const char *name;
 962
 963                         this_ret = bt_field_type_common_structure_borrow_field_by_index(
 964                                 field->type, &name, NULL, i);
 965                         BT_ASSERT(this_ret == 0);
 966                         BT_ASSERT_PRE_MSG("Invalid structure field's field: "
 967                                 "%![struct-field-]+_f, field-name=\"%s\", "
 968                                 "index=%" PRId64 ", %![field-]+_f",
 969                                 field, name, i, structure->fields->pdata[i]);
 970                         goto end;
 971                 }
 972         }
 973
 974 end:
 975         return ret;
 976 }
 977
 978 BT_HIDDEN
 979 int bt_field_common_variant_validate_recursive(struct bt_field_common *field)
 980 {
 981         int ret = 0;
 982         struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
 983
 984         BT_ASSERT(field);
 985
 986         if (!variant->current_field) {
 987                 ret = -1;
 988                 goto end;
 989         }
 990
 991         ret = bt_field_common_validate_recursive(variant->current_field);
 992
 993 end:
 994         return ret;
 995 }
 996
 997 BT_HIDDEN
 998 int bt_field_common_array_validate_recursive(struct bt_field_common *field)
 999 {
1000         int64_t i;
1001         int ret = 0;
1002         struct bt_field_common_array *array = BT_FROM_COMMON(field);
1003
1004         BT_ASSERT(field);
1005
1006         for (i = 0; i < array->elements->len; i++) {
1007                 ret = bt_field_common_validate_recursive((void *) array->elements->pdata[i]);
1008                 if (ret) {
1009                         BT_ASSERT_PRE_MSG("Invalid array field's element field: "
1010                                 "%![array-field-]+_f, " PRId64 ", "
1011                                 "%![elem-field-]+_f",
1012                                 field, i, array->elements->pdata[i]);
1013                         goto end;
1014                 }
1015         }
1016
1017 end:
1018         return ret;
1019 }
1020
1021 BT_HIDDEN
1022 int bt_field_common_sequence_validate_recursive(struct bt_field_common *field)
1023 {
1024         size_t i;
1025         int ret = 0;
1026         struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
1027
1028         BT_ASSERT(field);
1029
1030         for (i = 0; i < sequence->elements->len; i++) {
1031                 ret = bt_field_common_validate_recursive(
1032                         (void *) sequence->elements->pdata[i]);
1033                 if (ret) {
1034                         BT_ASSERT_PRE_MSG("Invalid sequence field's element field: "
1035                                 "%![seq-field-]+_f, " PRId64 ", "
1036                                 "%![elem-field-]+_f",
1037                                 field, i, sequence->elements->pdata[i]);
1038                         goto end;
1039                 }
1040         }
1041 end:
1042         return ret;
1043 }
1044
1045 BT_HIDDEN
1046 void bt_field_common_generic_reset(struct bt_field_common *field)
1047 {
1048         BT_ASSERT(field);
1049         field->payload_set = false;
1050 }
1051
1052 BT_HIDDEN
1053 void bt_field_common_structure_reset_recursive(struct bt_field_common *field)
1054 {
1055         int64_t i;
1056         struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
1057
1058         BT_ASSERT(field);
1059
1060         for (i = 0; i < structure->fields->len; i++) {
1061                 struct bt_field_common *member = structure->fields->pdata[i];
1062
1063                 if (!member) {
1064                         /*
1065                          * Structure members are lazily initialized;
1066                          * skip if this member has not been allocated
1067                          * yet.
1068                          */
1069                         continue;
1070                 }
1071
1072                 bt_field_common_reset_recursive(member);
1073         }
1074 }
1075
1076 BT_HIDDEN
1077 void bt_field_common_variant_reset_recursive(struct bt_field_common *field)
1078 {
1079         struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
1080
1081         BT_ASSERT(field);
1082         variant->current_field = NULL;
1083 }
1084
1085 BT_HIDDEN
1086 void bt_field_common_array_reset_recursive(struct bt_field_common *field)
1087 {
1088         size_t i;
1089         struct bt_field_common_array *array = BT_FROM_COMMON(field);
1090
1091         BT_ASSERT(field);
1092
1093         for (i = 0; i < array->elements->len; i++) {
1094                 struct bt_field_common *member = array->elements->pdata[i];
1095
1096                 if (!member) {
1097                         /*
1098                          * Array elements are lazily initialized; skip
1099                          * if this member has not been allocated yet.
1100                          */
1101                         continue;
1102                 }
1103
1104                 bt_field_common_reset_recursive(member);
1105         }
1106 }
1107
1108 BT_HIDDEN
1109 void bt_field_common_sequence_reset_recursive(struct bt_field_common *field)
1110 {
1111         struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
1112         uint64_t i;
1113
1114         BT_ASSERT(field);
1115
1116         for (i = 0; i < sequence->elements->len; i++) {
1117                 if (sequence->elements->pdata[i]) {
1118                         bt_field_common_reset_recursive(
1119                                 sequence->elements->pdata[i]);
1120                 }
1121         }
1122
1123         sequence->length = 0;
1124 }
1125
1126 BT_HIDDEN
1127 void bt_field_common_string_reset(struct bt_field_common *field)
1128 {
1129         struct bt_field_common_string *string = BT_FROM_COMMON(field);
1130
1131         BT_ASSERT(field);
1132         bt_field_common_generic_reset(field);
1133
1134         if (string->payload) {
1135                 g_string_truncate(string->payload, 0);
1136         }
1137 }
1138
1139 BT_HIDDEN
1140 void bt_field_common_generic_set_is_frozen(struct bt_field_common *field,
1141                 bool is_frozen)
1142 {
1143         field->frozen = is_frozen;
1144 }
1145
1146 BT_HIDDEN
1147 void bt_field_common_structure_set_is_frozen_recursive(
1148                 struct bt_field_common *field, bool is_frozen)
1149 {
1150         uint64_t i;
1151         struct bt_field_common_structure *structure_field =
1152                 BT_FROM_COMMON(field);
1153
1154         BT_LOGD("Freezing structure field object: addr=%p", field);
1155
1156         for (i = 0; i < structure_field->fields->len; i++) {
1157                 struct bt_field_common *struct_field =
1158                         g_ptr_array_index(structure_field->fields, i);
1159
1160                 BT_LOGD("Freezing structure field's field: field-addr=%p, index=%" PRId64,
1161                         struct_field, i);
1162                 bt_field_common_set_is_frozen_recursive(struct_field,
1163                         is_frozen);
1164         }
1165
1166         bt_field_common_generic_set_is_frozen(field, is_frozen);
1167 }
1168
1169 BT_HIDDEN
1170 void bt_field_common_variant_set_is_frozen_recursive(
1171                 struct bt_field_common *field, bool is_frozen)
1172 {
1173         uint64_t i;
1174         struct bt_field_common_variant *variant_field = BT_FROM_COMMON(field);
1175
1176         BT_LOGD("Freezing variant field object: addr=%p", field);
1177
1178         for (i = 0; i < variant_field->fields->len; i++) {
1179                 struct bt_field_common *var_field =
1180                         g_ptr_array_index(variant_field->fields, i);
1181
1182                 BT_LOGD("Freezing variant field's field: field-addr=%p, index=%" PRId64,
1183                         var_field, i);
1184                 bt_field_common_set_is_frozen_recursive(var_field, is_frozen);
1185         }
1186
1187         bt_field_common_generic_set_is_frozen(field, is_frozen);
1188 }
1189
1190 BT_HIDDEN
1191 void bt_field_common_array_set_is_frozen_recursive(
1192                 struct bt_field_common *field, bool is_frozen)
1193 {
1194         int64_t i;
1195         struct bt_field_common_array *array_field = BT_FROM_COMMON(field);
1196
1197         BT_LOGD("Freezing array field object: addr=%p", field);
1198
1199         for (i = 0; i < array_field->elements->len; i++) {
1200                 struct bt_field_common *elem_field =
1201                         g_ptr_array_index(array_field->elements, i);
1202
1203                 BT_LOGD("Freezing array field object's element field: "
1204                         "element-field-addr=%p, index=%" PRId64,
1205                         elem_field, i);
1206                 bt_field_common_set_is_frozen_recursive(elem_field, is_frozen);
1207         }
1208
1209         bt_field_common_generic_set_is_frozen(field, is_frozen);
1210 }
1211
1212 BT_HIDDEN
1213 void bt_field_common_sequence_set_is_frozen_recursive(
1214                 struct bt_field_common *field, bool is_frozen)
1215 {
1216         int64_t i;
1217         struct bt_field_common_sequence *sequence_field =
1218                 BT_FROM_COMMON(field);
1219
1220         BT_LOGD("Freezing sequence field object: addr=%p", field);
1221
1222         for (i = 0; i < sequence_field->length; i++) {
1223                 struct bt_field_common *elem_field =
1224                         g_ptr_array_index(sequence_field->elements, i);
1225
1226                 BT_LOGD("Freezing sequence field object's element field: "
1227                         "element-field-addr=%p, index=%" PRId64,
1228                         elem_field, i);
1229                 bt_field_common_set_is_frozen_recursive(elem_field, is_frozen);
1230         }
1231
1232         bt_field_common_generic_set_is_frozen(field, is_frozen);
1233 }
1234
1235 BT_HIDDEN
1236 void _bt_field_common_set_is_frozen_recursive(struct bt_field_common *field,
1237                 bool is_frozen)
1238 {
1239         if (!field) {
1240                 goto end;
1241         }
1242
1243         if (field->frozen) {
1244                 goto end;
1245         }
1246
1247         BT_LOGD("Setting field object's frozen state: addr=%p, is-frozen=%d",
1248                 field, is_frozen);
1249         BT_ASSERT(field_type_common_has_known_id(field->type));
1250         BT_ASSERT(field->methods->set_is_frozen);
1251         field->methods->set_is_frozen(field, is_frozen);
1252
1253 end:
1254         return;
1255 }
1256
1257 BT_HIDDEN
1258 bt_bool bt_field_common_generic_is_set(struct bt_field_common *field)
1259 {
1260         return field && field->payload_set;
1261 }
1262
1263 BT_HIDDEN
1264 bt_bool bt_field_common_structure_is_set_recursive(
1265                 struct bt_field_common *field)
1266 {
1267         bt_bool is_set = BT_FALSE;
1268         size_t i;
1269         struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
1270
1271         BT_ASSERT(field);
1272
1273         for (i = 0; i < structure->fields->len; i++) {
1274                 is_set = bt_field_common_is_set_recursive(
1275                         structure->fields->pdata[i]);
1276                 if (!is_set) {
1277                         goto end;
1278                 }
1279         }
1280
1281 end:
1282         return is_set;
1283 }
1284
1285 BT_HIDDEN
1286 bt_bool bt_field_common_variant_is_set_recursive(struct bt_field_common *field)
1287 {
1288         struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
1289         bt_bool is_set = BT_FALSE;
1290
1291         BT_ASSERT(field);
1292
1293         if (variant->current_field) {
1294                 is_set = bt_field_common_is_set_recursive(
1295                         variant->current_field);
1296         }
1297
1298         return is_set;
1299 }
1300
1301 BT_HIDDEN
1302 bt_bool bt_field_common_array_is_set_recursive(struct bt_field_common *field)
1303 {
1304         size_t i;
1305         bt_bool is_set = BT_FALSE;
1306         struct bt_field_common_array *array = BT_FROM_COMMON(field);
1307
1308         BT_ASSERT(field);
1309
1310         for (i = 0; i < array->elements->len; i++) {
1311                 is_set = bt_field_common_is_set_recursive(array->elements->pdata[i]);
1312                 if (!is_set) {
1313                         goto end;
1314                 }
1315         }
1316
1317 end:
1318         return is_set;
1319 }
1320
1321 BT_HIDDEN
1322 bt_bool bt_field_common_sequence_is_set_recursive(struct bt_field_common *field)
1323 {
1324         size_t i;
1325         bt_bool is_set = BT_FALSE;
1326         struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
1327
1328         BT_ASSERT(field);
1329
1330         if (!sequence->elements) {
1331                 goto end;
1332         }
1333
1334         for (i = 0; i < sequence->elements->len; i++) {
1335                 is_set = bt_field_common_is_set_recursive(
1336                         sequence->elements->pdata[i]);
1337                 if (!is_set) {
1338                         goto end;
1339                 }
1340         }
1341
1342 end:
1343         return is_set;
1344 }