src/lib/trace-ir/field-class.c

   1 /*
   2  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   3  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #define BT_LOG_TAG "LIB/FIELD-CLASS"
  25 #include "lib/logging.h"
  26
  27 #include "lib/assert-pre.h"
  28 #include <babeltrace2/trace-ir/field-class.h>
  29 #include <babeltrace2/trace-ir/field-class-const.h>
  30 #include <babeltrace2/trace-ir/field-const.h>
  31 #include <babeltrace2/trace-ir/field.h>
  32 #include <babeltrace2/trace-ir/clock-class.h>
  33 #include "lib/object.h"
  34 #include "compat/compiler.h"
  35 #include "compat/endian.h"
  36 #include "common/assert.h"
  37 #include "compat/glib.h"
  38 #include <float.h>
  39 #include <inttypes.h>
  40 #include <stdlib.h>
  41
  42 #include "clock-class.h"
  43 #include "field-class.h"
  44 #include "field.h"
  45 #include "field-path.h"
  46 #include "utils.h"
  47 #include "lib/func-status.h"
  48
  49 enum bt_field_class_type bt_field_class_get_type(
  50                 const struct bt_field_class *fc)
  51 {
  52         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
  53         return fc->type;
  54 }
  55
  56 static
  57 void init_field_class(struct bt_field_class *fc, enum bt_field_class_type type,
  58                 bt_object_release_func release_func)
  59 {
  60         BT_ASSERT(fc);
  61         BT_ASSERT(bt_field_class_has_known_type(fc));
  62         BT_ASSERT(release_func);
  63         bt_object_init_shared(&fc->base, release_func);
  64         fc->type = type;
  65 }
  66
  67 static
  68 void init_integer_field_class(struct bt_field_class_integer *fc,
  69                 enum bt_field_class_type type,
  70                 bt_object_release_func release_func)
  71 {
  72         init_field_class((void *) fc, type, release_func);
  73         fc->range = 64;
  74         fc->base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
  75 }
  76
  77 static
  78 void destroy_integer_field_class(struct bt_object *obj)
  79 {
  80         BT_ASSERT(obj);
  81         BT_LIB_LOGD("Destroying integer field class object: %!+F", obj);
  82         g_free(obj);
  83 }
  84
  85 static inline
  86 struct bt_field_class *create_integer_field_class(bt_trace_class *trace_class,
  87                 enum bt_field_class_type type)
  88 {
  89         struct bt_field_class_integer *int_fc = NULL;
  90
  91         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
  92         BT_LOGD("Creating default integer field class object: type=%s",
  93                 bt_common_field_class_type_string(type));
  94         int_fc = g_new0(struct bt_field_class_integer, 1);
  95         if (!int_fc) {
  96                 BT_LIB_LOGE_APPEND_CAUSE(
  97                         "Failed to allocate one integer field class.");
  98                 goto error;
  99         }
 100
 101         init_integer_field_class(int_fc, type, destroy_integer_field_class);
 102         BT_LIB_LOGD("Created integer field class object: %!+F", int_fc);
 103         goto end;
 104
 105 error:
 106         BT_OBJECT_PUT_REF_AND_RESET(int_fc);
 107
 108 end:
 109         return (void *) int_fc;
 110 }
 111
 112 struct bt_field_class *bt_field_class_unsigned_integer_create(
 113                 bt_trace_class *trace_class)
 114 {
 115         return create_integer_field_class(trace_class,
 116                 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
 117 }
 118
 119 struct bt_field_class *bt_field_class_signed_integer_create(
 120                 bt_trace_class *trace_class)
 121 {
 122         return create_integer_field_class(trace_class,
 123                 BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
 124 }
 125
 126 uint64_t bt_field_class_integer_get_field_value_range(
 127                 const struct bt_field_class *fc)
 128 {
 129         const struct bt_field_class_integer *int_fc = (const void *) fc;
 130
 131         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 132         BT_ASSERT_PRE_DEV_FC_IS_INT(fc, "Field class");
 133         return int_fc->range;
 134 }
 135
 136 BT_ASSERT_PRE_FUNC
 137 static
 138 bool size_is_valid_for_enumeration_field_class(struct bt_field_class *fc,
 139                 uint64_t size)
 140 {
 141         // TODO
 142         return true;
 143 }
 144
 145 void bt_field_class_integer_set_field_value_range(
 146                 struct bt_field_class *fc, uint64_t size)
 147 {
 148         struct bt_field_class_integer *int_fc = (void *) fc;
 149
 150         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 151         BT_ASSERT_PRE_FC_IS_INT(fc, "Field class");
 152         BT_ASSERT_PRE_DEV_FC_HOT(fc, "Field class");
 153         BT_ASSERT_PRE(size <= 64,
 154                 "Unsupported size for integer field class's field value range "
 155                 "(maximum is 64): size=%" PRIu64, size);
 156         BT_ASSERT_PRE(
 157                 int_fc->common.type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
 158                 int_fc->common.type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
 159                 size_is_valid_for_enumeration_field_class(fc, size),
 160                 "Invalid field value range for enumeration field class: "
 161                 "at least one of the current mapping ranges contains values "
 162                 "which are outside this range: %!+F, size=%" PRIu64, fc, size);
 163         int_fc->range = size;
 164         BT_LIB_LOGD("Set integer field class's field value range: %!+F", fc);
 165 }
 166
 167 enum bt_field_class_integer_preferred_display_base
 168 bt_field_class_integer_get_preferred_display_base(const struct bt_field_class *fc)
 169 {
 170         const struct bt_field_class_integer *int_fc = (const void *) fc;
 171
 172         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 173         BT_ASSERT_PRE_DEV_FC_IS_INT(fc, "Field class");
 174         return int_fc->base;
 175 }
 176
 177 void bt_field_class_integer_set_preferred_display_base(
 178                 struct bt_field_class *fc,
 179                 enum bt_field_class_integer_preferred_display_base base)
 180 {
 181         struct bt_field_class_integer *int_fc = (void *) fc;
 182
 183         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 184         BT_ASSERT_PRE_FC_IS_INT(fc, "Field class");
 185         BT_ASSERT_PRE_DEV_FC_HOT(fc, "Field class");
 186         int_fc->base = base;
 187         BT_LIB_LOGD("Set integer field class's preferred display base: %!+F", fc);
 188 }
 189
 190 static
 191 void finalize_enumeration_field_class_mapping(
 192                 struct bt_field_class_enumeration_mapping *mapping)
 193 {
 194         BT_ASSERT(mapping);
 195
 196         if (mapping->label) {
 197                 g_string_free(mapping->label, TRUE);
 198         }
 199
 200         if (mapping->ranges) {
 201                 g_array_free(mapping->ranges, TRUE);
 202         }
 203 }
 204
 205 static
 206 void destroy_enumeration_field_class(struct bt_object *obj)
 207 {
 208         struct bt_field_class_enumeration *fc = (void *) obj;
 209
 210         BT_ASSERT(fc);
 211         BT_LIB_LOGD("Destroying enumeration field class object: %!+F", fc);
 212
 213         if (fc->mappings) {
 214                 uint64_t i;
 215
 216                 for (i = 0; i < fc->mappings->len; i++) {
 217                         finalize_enumeration_field_class_mapping(
 218                                 BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(fc, i));
 219                 }
 220
 221                 g_array_free(fc->mappings, TRUE);
 222                 fc->mappings = NULL;
 223         }
 224
 225         if (fc->label_buf) {
 226                 g_ptr_array_free(fc->label_buf, TRUE);
 227                 fc->label_buf = NULL;
 228         }
 229
 230         g_free(fc);
 231 }
 232
 233 static
 234 struct bt_field_class *create_enumeration_field_class(
 235                 bt_trace_class *trace_class, enum bt_field_class_type type)
 236 {
 237         struct bt_field_class_enumeration *enum_fc = NULL;
 238
 239         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
 240         BT_LOGD("Creating default enumeration field class object: type=%s",
 241                 bt_common_field_class_type_string(type));
 242         enum_fc = g_new0(struct bt_field_class_enumeration, 1);
 243         if (!enum_fc) {
 244                 BT_LIB_LOGE_APPEND_CAUSE(
 245                         "Failed to allocate one enumeration field class.");
 246                 goto error;
 247         }
 248
 249         init_integer_field_class((void *) enum_fc, type,
 250                 destroy_enumeration_field_class);
 251         enum_fc->mappings = g_array_new(FALSE, TRUE,
 252                 sizeof(struct bt_field_class_enumeration_mapping));
 253         if (!enum_fc->mappings) {
 254                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GArray.");
 255                 goto error;
 256         }
 257
 258         enum_fc->label_buf = g_ptr_array_new();
 259         if (!enum_fc->label_buf) {
 260                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GArray.");
 261                 goto error;
 262         }
 263
 264         BT_LIB_LOGD("Created enumeration field class object: %!+F", enum_fc);
 265         goto end;
 266
 267 error:
 268         BT_OBJECT_PUT_REF_AND_RESET(enum_fc);
 269
 270 end:
 271         return (void *) enum_fc;
 272 }
 273
 274 struct bt_field_class *bt_field_class_unsigned_enumeration_create(
 275                 bt_trace_class *trace_class)
 276 {
 277         return create_enumeration_field_class(trace_class,
 278                 BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
 279 }
 280
 281 struct bt_field_class *bt_field_class_signed_enumeration_create(
 282                 bt_trace_class *trace_class)
 283 {
 284         return create_enumeration_field_class(trace_class,
 285                 BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
 286 }
 287
 288 uint64_t bt_field_class_enumeration_get_mapping_count(
 289                 const struct bt_field_class *fc)
 290 {
 291         const struct bt_field_class_enumeration *enum_fc = (const void *) fc;
 292
 293         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 294         BT_ASSERT_PRE_DEV_FC_IS_ENUM(fc, "Field class");
 295         return (uint64_t) enum_fc->mappings->len;
 296 }
 297
 298 const struct bt_field_class_unsigned_enumeration_mapping *
 299 bt_field_class_unsigned_enumeration_borrow_mapping_by_index_const(
 300                 const struct bt_field_class *fc, uint64_t index)
 301 {
 302         const struct bt_field_class_enumeration *enum_fc = (const void *) fc;
 303
 304         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 305         BT_ASSERT_PRE_DEV_VALID_INDEX(index, enum_fc->mappings->len);
 306         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
 307                 "Field class");
 308         return (const void *) BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(fc, index);
 309 }
 310
 311 const struct bt_field_class_signed_enumeration_mapping *
 312 bt_field_class_signed_enumeration_borrow_mapping_by_index_const(
 313                 const struct bt_field_class *fc, uint64_t index)
 314 {
 315         const struct bt_field_class_enumeration *enum_fc = (const void *) fc;
 316
 317         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 318         BT_ASSERT_PRE_DEV_VALID_INDEX(index, enum_fc->mappings->len);
 319         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
 320                 "Field class");
 321         return (const void *) BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(fc, index);
 322 }
 323
 324 const char *bt_field_class_enumeration_mapping_get_label(
 325                 const struct bt_field_class_enumeration_mapping *mapping)
 326 {
 327         BT_ASSERT_PRE_DEV_NON_NULL(mapping, "Enumeration field class mapping");
 328         return mapping->label->str;
 329 }
 330
 331 uint64_t bt_field_class_enumeration_mapping_get_range_count(
 332                 const struct bt_field_class_enumeration_mapping *mapping)
 333 {
 334         BT_ASSERT_PRE_DEV_NON_NULL(mapping, "Enumeration field class mapping");
 335         return (uint64_t) mapping->ranges->len;
 336 }
 337
 338 static inline
 339 void get_enumeration_field_class_mapping_range_at_index(
 340                 const struct bt_field_class_enumeration_mapping *mapping,
 341                 uint64_t index, uint64_t *lower, uint64_t *upper)
 342 {
 343         const struct bt_field_class_enumeration_mapping_range *range;
 344
 345         BT_ASSERT_PRE_DEV_NON_NULL(mapping, "Ranges");
 346         BT_ASSERT_PRE_DEV_NON_NULL(lower, "Range's lower (output)");
 347         BT_ASSERT_PRE_DEV_NON_NULL(upper, "Range's upper (output)");
 348         BT_ASSERT_PRE_DEV_VALID_INDEX(index, mapping->ranges->len);
 349         range = BT_FIELD_CLASS_ENUM_MAPPING_RANGE_AT_INDEX(mapping, index);
 350         *lower = range->lower.u;
 351         *upper = range->upper.u;
 352 }
 353
 354 void bt_field_class_unsigned_enumeration_mapping_get_range_by_index(
 355                 const struct bt_field_class_unsigned_enumeration_mapping *ranges,
 356                 uint64_t index, uint64_t *lower, uint64_t *upper)
 357 {
 358         get_enumeration_field_class_mapping_range_at_index(
 359                 (const void *) ranges, index, lower, upper);
 360 }
 361
 362 void bt_field_class_signed_enumeration_mapping_get_range_by_index(
 363                 const struct bt_field_class_signed_enumeration_mapping *ranges,
 364                 uint64_t index, int64_t *lower, int64_t *upper)
 365 {
 366         get_enumeration_field_class_mapping_range_at_index(
 367                 (const void *) ranges, index,
 368                 (uint64_t *) lower, (uint64_t *) upper);
 369 }
 370
 371 enum bt_field_class_enumeration_get_mapping_labels_for_value_status
 372 bt_field_class_unsigned_enumeration_get_mapping_labels_for_value(
 373                 const struct bt_field_class *fc, uint64_t value,
 374                 bt_field_class_enumeration_mapping_label_array *label_array,
 375                 uint64_t *count)
 376 {
 377         const struct bt_field_class_enumeration *enum_fc = (const void *) fc;
 378         uint64_t i;
 379
 380         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 381         BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Label array (output)");
 382         BT_ASSERT_PRE_DEV_NON_NULL(count, "Count (output)");
 383         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
 384                 "Field class");
 385         g_ptr_array_set_size(enum_fc->label_buf, 0);
 386
 387         for (i = 0; i < enum_fc->mappings->len; i++) {
 388                 uint64_t j;
 389                 const struct bt_field_class_enumeration_mapping *mapping =
 390                         BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(enum_fc, i);
 391
 392                 for (j = 0; j < mapping->ranges->len; j++) {
 393                         const struct bt_field_class_enumeration_mapping_range *range =
 394                                 BT_FIELD_CLASS_ENUM_MAPPING_RANGE_AT_INDEX(
 395                                         mapping, j);
 396
 397                         if (value >= range->lower.u &&
 398                                         value <= range->upper.u) {
 399                                 g_ptr_array_add(enum_fc->label_buf,
 400                                         mapping->label->str);
 401                                 break;
 402                         }
 403                 }
 404         }
 405
 406         *label_array = (void *) enum_fc->label_buf->pdata;
 407         *count = (uint64_t) enum_fc->label_buf->len;
 408         return BT_FUNC_STATUS_OK;
 409 }
 410
 411 enum bt_field_class_enumeration_get_mapping_labels_for_value_status
 412 bt_field_class_signed_enumeration_get_mapping_labels_for_value(
 413                 const struct bt_field_class *fc, int64_t value,
 414                 bt_field_class_enumeration_mapping_label_array *label_array,
 415                 uint64_t *count)
 416 {
 417         const struct bt_field_class_enumeration *enum_fc = (const void *) fc;
 418         uint64_t i;
 419
 420         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 421         BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Label array (output)");
 422         BT_ASSERT_PRE_DEV_NON_NULL(count, "Count (output)");
 423         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
 424                 "Field class");
 425         g_ptr_array_set_size(enum_fc->label_buf, 0);
 426
 427         for (i = 0; i < enum_fc->mappings->len; i++) {
 428                 uint64_t j;
 429                 const struct bt_field_class_enumeration_mapping *mapping =
 430                         BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(enum_fc, i);
 431
 432                 for (j = 0; j < mapping->ranges->len; j++) {
 433                         const struct bt_field_class_enumeration_mapping_range *range =
 434                                 BT_FIELD_CLASS_ENUM_MAPPING_RANGE_AT_INDEX(
 435                                         mapping, j);
 436
 437                         if (value >= range->lower.i &&
 438                                         value <= range->upper.i) {
 439                                 g_ptr_array_add(enum_fc->label_buf,
 440                                         mapping->label->str);
 441                                 break;
 442                         }
 443                 }
 444         }
 445
 446         *label_array = (void *) enum_fc->label_buf->pdata;
 447         *count = (uint64_t) enum_fc->label_buf->len;
 448         return BT_FUNC_STATUS_OK;
 449 }
 450
 451 static inline
 452 enum bt_field_class_enumeration_map_range_status
 453 add_mapping_to_enumeration_field_class(
 454                 struct bt_field_class *fc,
 455                 const char *label, uint64_t lower, uint64_t upper)
 456 {
 457         int ret = BT_FUNC_STATUS_OK;
 458         uint64_t i;
 459         struct bt_field_class_enumeration *enum_fc = (void *) fc;
 460         struct bt_field_class_enumeration_mapping *mapping = NULL;
 461         struct bt_field_class_enumeration_mapping_range *range;
 462
 463         BT_ASSERT(fc);
 464         BT_ASSERT_PRE_NON_NULL(label, "Label");
 465
 466         /* Find existing mapping identified by this label */
 467         for (i = 0; i < enum_fc->mappings->len; i++) {
 468                 struct bt_field_class_enumeration_mapping *mapping_candidate =
 469                         BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(enum_fc, i);
 470
 471                 if (strcmp(mapping_candidate->label->str, label) == 0) {
 472                         mapping = mapping_candidate;
 473                         break;
 474                 }
 475         }
 476
 477         if (!mapping) {
 478                 /* Create new mapping for this label */
 479                 g_array_set_size(enum_fc->mappings, enum_fc->mappings->len + 1);
 480                 mapping = BT_FIELD_CLASS_ENUM_MAPPING_AT_INDEX(enum_fc,
 481                         enum_fc->mappings->len - 1);
 482                 mapping->ranges = g_array_new(FALSE, TRUE,
 483                         sizeof(struct bt_field_class_enumeration_mapping_range));
 484                 if (!mapping->ranges) {
 485                         finalize_enumeration_field_class_mapping(mapping);
 486                         g_array_set_size(enum_fc->mappings,
 487                                 enum_fc->mappings->len - 1);
 488                         ret = BT_FUNC_STATUS_MEMORY_ERROR;
 489                         goto end;
 490                 }
 491
 492                 mapping->label = g_string_new(label);
 493                 if (!mapping->label) {
 494                         finalize_enumeration_field_class_mapping(mapping);
 495                         g_array_set_size(enum_fc->mappings,
 496                                 enum_fc->mappings->len - 1);
 497                         ret = BT_FUNC_STATUS_MEMORY_ERROR;
 498                         goto end;
 499                 }
 500         }
 501
 502         /* Add range */
 503         BT_ASSERT(mapping);
 504         g_array_set_size(mapping->ranges, mapping->ranges->len + 1);
 505         range = BT_FIELD_CLASS_ENUM_MAPPING_RANGE_AT_INDEX(mapping,
 506                 mapping->ranges->len - 1);
 507         range->lower.u = lower;
 508         range->upper.u = upper;
 509         BT_LIB_LOGD("Added mapping to enumeration field class: "
 510                 "%![fc-]+F, label=\"%s\", lower-unsigned=%" PRIu64 ", "
 511                 "upper-unsigned=%" PRIu64, fc, label, lower, upper);
 512
 513 end:
 514         return ret;
 515 }
 516
 517 enum bt_field_class_enumeration_map_range_status
 518 bt_field_class_unsigned_enumeration_map_range(
 519                 struct bt_field_class *fc, const char *label,
 520                 uint64_t range_lower, uint64_t range_upper)
 521 {
 522         struct bt_field_class_enumeration *enum_fc = (void *) fc;
 523
 524         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 525         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
 526                 "Field class");
 527         BT_ASSERT_PRE(range_lower <= range_upper,
 528                 "Range's upper bound is less than lower bound: "
 529                 "upper=%" PRIu64 ", lower=%" PRIu64,
 530                 range_lower, range_upper);
 531         BT_ASSERT_PRE(bt_util_value_is_in_range_unsigned(enum_fc->common.range,
 532                 range_lower),
 533                 "Range's lower bound is outside the enumeration field class's value range: "
 534                 "%![fc-]+F, lower=%" PRIu64, fc, range_lower);
 535         BT_ASSERT_PRE(bt_util_value_is_in_range_unsigned(enum_fc->common.range,
 536                 range_upper),
 537                 "Range's upper bound is outside the enumeration field class's value range: "
 538                 "%![fc-]+F, upper=%" PRIu64, fc, range_upper);
 539         return add_mapping_to_enumeration_field_class(fc, label, range_lower,
 540                 range_upper);
 541 }
 542
 543 enum bt_field_class_enumeration_map_range_status
 544 bt_field_class_signed_enumeration_map_range(
 545                 struct bt_field_class *fc, const char *label,
 546                 int64_t range_lower, int64_t range_upper)
 547 {
 548         struct bt_field_class_enumeration *enum_fc = (void *) fc;
 549
 550         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 551         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
 552                 "Field class");
 553         BT_ASSERT_PRE(range_lower <= range_upper,
 554                 "Range's upper bound is less than lower bound: "
 555                 "upper=%" PRId64 ", lower=%" PRId64,
 556                 range_lower, range_upper);
 557         BT_ASSERT_PRE(bt_util_value_is_in_range_signed(enum_fc->common.range,
 558                 range_lower),
 559                 "Range's lower bound is outside the enumeration field class's value range: "
 560                 "%![fc-]+F, lower=%" PRId64, fc, range_lower);
 561         BT_ASSERT_PRE(bt_util_value_is_in_range_signed(enum_fc->common.range,
 562                 range_upper),
 563                 "Range's upper bound is outside the enumeration field class's value range: "
 564                 "%![fc-]+F, upper=%" PRId64, fc, range_upper);
 565         return add_mapping_to_enumeration_field_class(fc, label, range_lower,
 566                 range_upper);
 567 }
 568
 569 static
 570 void destroy_real_field_class(struct bt_object *obj)
 571 {
 572         BT_ASSERT(obj);
 573         BT_LIB_LOGD("Destroying real field class object: %!+F", obj);
 574         g_free(obj);
 575 }
 576
 577 struct bt_field_class *bt_field_class_real_create(bt_trace_class *trace_class)
 578 {
 579         struct bt_field_class_real *real_fc = NULL;
 580
 581         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
 582         BT_LOGD_STR("Creating default real field class object.");
 583         real_fc = g_new0(struct bt_field_class_real, 1);
 584         if (!real_fc) {
 585                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one real field class.");
 586                 goto error;
 587         }
 588
 589         init_field_class((void *) real_fc, BT_FIELD_CLASS_TYPE_REAL,
 590                 destroy_real_field_class);
 591         BT_LIB_LOGD("Created real field class object: %!+F", real_fc);
 592         goto end;
 593
 594 error:
 595         BT_OBJECT_PUT_REF_AND_RESET(real_fc);
 596
 597 end:
 598         return (void *) real_fc;
 599 }
 600
 601 bt_bool bt_field_class_real_is_single_precision(const struct bt_field_class *fc)
 602 {
 603         const struct bt_field_class_real *real_fc = (const void *) fc;
 604
 605         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 606         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_REAL, "Field class");
 607         return real_fc->is_single_precision;
 608 }
 609
 610 void bt_field_class_real_set_is_single_precision(struct bt_field_class *fc,
 611                 bt_bool is_single_precision)
 612 {
 613         struct bt_field_class_real *real_fc = (void *) fc;
 614
 615         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 616         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_REAL, "Field class");
 617         BT_ASSERT_PRE_DEV_FC_HOT(fc, "Field class");
 618         real_fc->is_single_precision = (bool) is_single_precision;
 619         BT_LIB_LOGD("Set real field class's \"is single precision\" property: "
 620                 "%!+F", fc);
 621 }
 622
 623 static
 624 int init_named_field_classes_container(
 625                 struct bt_field_class_named_field_class_container *fc,
 626                 enum bt_field_class_type type,
 627                 bt_object_release_func release_func)
 628 {
 629         int ret = 0;
 630
 631         init_field_class((void *) fc, type, release_func);
 632         fc->named_fcs = g_array_new(FALSE, TRUE,
 633                 sizeof(struct bt_named_field_class));
 634         if (!fc->named_fcs) {
 635                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GArray.");
 636                 ret = -1;
 637                 goto end;
 638         }
 639
 640         fc->name_to_index = g_hash_table_new(g_str_hash, g_str_equal);
 641         if (!fc->name_to_index) {
 642                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GHashTable.");
 643                 ret = -1;
 644                 goto end;
 645         }
 646
 647 end:
 648         return ret;
 649 }
 650
 651 static
 652 void finalize_named_field_class(struct bt_named_field_class *named_fc)
 653 {
 654         BT_ASSERT(named_fc);
 655         BT_LIB_LOGD("Finalizing named field class: "
 656                 "addr=%p, name=\"%s\", %![fc-]+F",
 657                 named_fc, named_fc->name ? named_fc->name->str : NULL,
 658                 named_fc->fc);
 659
 660         if (named_fc->name) {
 661                 g_string_free(named_fc->name, TRUE);
 662         }
 663
 664         BT_LOGD_STR("Putting named field class's field class.");
 665         BT_OBJECT_PUT_REF_AND_RESET(named_fc->fc);
 666 }
 667
 668 static
 669 void finalize_named_field_classes_container(
 670                 struct bt_field_class_named_field_class_container *fc)
 671 {
 672         uint64_t i;
 673
 674         BT_ASSERT(fc);
 675
 676         if (fc->named_fcs) {
 677                 for (i = 0; i < fc->named_fcs->len; i++) {
 678                         finalize_named_field_class(
 679                                 &g_array_index(fc->named_fcs,
 680                                         struct bt_named_field_class, i));
 681                 }
 682
 683                 g_array_free(fc->named_fcs, TRUE);
 684         }
 685
 686         if (fc->name_to_index) {
 687                 g_hash_table_destroy(fc->name_to_index);
 688         }
 689 }
 690
 691 static
 692 void destroy_structure_field_class(struct bt_object *obj)
 693 {
 694         BT_ASSERT(obj);
 695         BT_LIB_LOGD("Destroying structure field class object: %!+F", obj);
 696         finalize_named_field_classes_container((void *) obj);
 697         g_free(obj);
 698 }
 699
 700 struct bt_field_class *bt_field_class_structure_create(
 701                 bt_trace_class *trace_class)
 702 {
 703         int ret;
 704         struct bt_field_class_structure *struct_fc = NULL;
 705
 706         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
 707         BT_LOGD_STR("Creating default structure field class object.");
 708         struct_fc = g_new0(struct bt_field_class_structure, 1);
 709         if (!struct_fc) {
 710                 BT_LIB_LOGE_APPEND_CAUSE(
 711                         "Failed to allocate one structure field class.");
 712                 goto error;
 713         }
 714
 715         ret = init_named_field_classes_container((void *) struct_fc,
 716                 BT_FIELD_CLASS_TYPE_STRUCTURE, destroy_structure_field_class);
 717         if (ret) {
 718                 goto error;
 719         }
 720
 721         BT_LIB_LOGD("Created structure field class object: %!+F", struct_fc);
 722         goto end;
 723
 724 error:
 725         BT_OBJECT_PUT_REF_AND_RESET(struct_fc);
 726
 727 end:
 728         return (void *) struct_fc;
 729 }
 730
 731 static
 732 int append_named_field_class_to_container_field_class(
 733                 struct bt_field_class_named_field_class_container *container_fc,
 734                 const char *name, struct bt_field_class *fc)
 735 {
 736         int ret = BT_FUNC_STATUS_OK;
 737         struct bt_named_field_class *named_fc;
 738         GString *name_str;
 739
 740         BT_ASSERT(container_fc);
 741         BT_ASSERT_PRE_DEV_FC_HOT(container_fc, "Field class");
 742         BT_ASSERT_PRE_NON_NULL(name, "Name");
 743         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 744         BT_ASSERT_PRE(!bt_g_hash_table_contains(container_fc->name_to_index,
 745                 name),
 746                 "Duplicate member/option name in structure/variant field class: "
 747                 "%![container-fc-]+F, name=\"%s\"", container_fc, name);
 748         name_str = g_string_new(name);
 749         if (!name_str) {
 750                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
 751                 ret = BT_FUNC_STATUS_MEMORY_ERROR;
 752                 goto end;
 753         }
 754
 755         g_array_set_size(container_fc->named_fcs,
 756                 container_fc->named_fcs->len + 1);
 757         named_fc = &g_array_index(container_fc->named_fcs,
 758                 struct bt_named_field_class, container_fc->named_fcs->len - 1);
 759         named_fc->name = name_str;
 760         named_fc->fc = fc;
 761         bt_object_get_no_null_check(fc);
 762         g_hash_table_insert(container_fc->name_to_index, named_fc->name->str,
 763                 GUINT_TO_POINTER(container_fc->named_fcs->len - 1));
 764
 765         /*
 766          * Freeze the field class, but not the named field class (the
 767          * user can still modify it, if possible, until the container
 768          * itself is frozen).
 769          */
 770         bt_field_class_freeze(fc);
 771
 772 end:
 773         return ret;
 774 }
 775
 776 enum bt_field_class_structure_append_member_status
 777 bt_field_class_structure_append_member(
 778                 struct bt_field_class *fc, const char *name,
 779                 struct bt_field_class *member_fc)
 780 {
 781
 782         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 783         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STRUCTURE,
 784                 "Field class");
 785         return append_named_field_class_to_container_field_class((void *) fc,
 786                 name, member_fc);
 787 }
 788
 789 uint64_t bt_field_class_structure_get_member_count(
 790                 const struct bt_field_class *fc)
 791 {
 792         struct bt_field_class_structure *struct_fc = (void *) fc;
 793
 794         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 795         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STRUCTURE,
 796                 "Field class");
 797         return (uint64_t) struct_fc->common.named_fcs->len;
 798 }
 799
 800 static
 801 struct bt_named_field_class *
 802 borrow_named_field_class_from_container_field_class_at_index(
 803                 struct bt_field_class_named_field_class_container *fc,
 804                 uint64_t index)
 805 {
 806         BT_ASSERT(fc);
 807         BT_ASSERT_PRE_DEV_VALID_INDEX(index, fc->named_fcs->len);
 808         return BT_FIELD_CLASS_NAMED_FC_AT_INDEX(fc, index);
 809 }
 810
 811 const struct bt_field_class_structure_member *
 812 bt_field_class_structure_borrow_member_by_index_const(
 813                 const struct bt_field_class *fc, uint64_t index)
 814 {
 815         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 816         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STRUCTURE,
 817                 "Field class");
 818         return (const void *)
 819                 borrow_named_field_class_from_container_field_class_at_index(
 820                         (void *) fc, index);
 821 }
 822
 823 struct bt_field_class_structure_member *
 824 bt_field_class_structure_borrow_member_by_index(
 825                 struct bt_field_class *fc, uint64_t index)
 826 {
 827         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 828         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STRUCTURE,
 829                 "Field class");
 830         return (void *)
 831                 borrow_named_field_class_from_container_field_class_at_index(
 832                         (void *) fc, index);
 833 }
 834
 835 static
 836 struct bt_named_field_class *
 837 borrow_named_field_class_from_container_field_class_by_name(
 838                 struct bt_field_class_named_field_class_container *fc,
 839                 const char *name)
 840 {
 841         struct bt_named_field_class *named_fc = NULL;
 842         gpointer orig_key;
 843         gpointer value;
 844
 845         BT_ASSERT(fc);
 846         BT_ASSERT_PRE_DEV_NON_NULL(name, "Name");
 847         if (!g_hash_table_lookup_extended(fc->name_to_index, name, &orig_key,
 848                         &value)) {
 849                 goto end;
 850         }
 851
 852         named_fc = BT_FIELD_CLASS_NAMED_FC_AT_INDEX(fc,
 853                 GPOINTER_TO_UINT(value));
 854
 855 end:
 856         return named_fc;
 857 }
 858
 859 const struct bt_field_class_structure_member *
 860 bt_field_class_structure_borrow_member_by_name_const(
 861                 const struct bt_field_class *fc, const char *name)
 862 {
 863         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 864         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STRUCTURE,
 865                 "Field class");
 866         return (const void *)
 867                 borrow_named_field_class_from_container_field_class_by_name(
 868                         (void *) fc, name);
 869 }
 870
 871 struct bt_field_class_structure_member *
 872 bt_field_class_structure_borrow_member_by_name(
 873                 struct bt_field_class *fc, const char *name)
 874 {
 875         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 876         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STRUCTURE,
 877                 "Field class");
 878         return (void *)
 879                 borrow_named_field_class_from_container_field_class_by_name(
 880                         (void *) fc, name);
 881 }
 882
 883 const char *bt_field_class_structure_member_get_name(
 884                 const struct bt_field_class_structure_member *member)
 885 {
 886         const struct bt_named_field_class *named_fc = (const void *) member;
 887
 888         BT_ASSERT_PRE_DEV_NON_NULL(member, "Structure field class member");
 889         return named_fc->name->str;
 890 }
 891
 892 const struct bt_field_class *
 893 bt_field_class_structure_member_borrow_field_class_const(
 894                 const struct bt_field_class_structure_member *member)
 895 {
 896         const struct bt_named_field_class *named_fc = (const void *) member;
 897
 898         BT_ASSERT_PRE_DEV_NON_NULL(member, "Structure field class member");
 899         return named_fc->fc;
 900 }
 901
 902 struct bt_field_class *
 903 bt_field_class_structure_member_borrow_field_class(
 904                 struct bt_field_class_structure_member *member)
 905 {
 906         struct bt_named_field_class *named_fc = (void *) member;
 907
 908         BT_ASSERT_PRE_DEV_NON_NULL(member, "Structure field class member");
 909         return named_fc->fc;
 910 }
 911
 912 static
 913 void destroy_variant_field_class(struct bt_object *obj)
 914 {
 915         struct bt_field_class_variant *fc = (void *) obj;
 916
 917         BT_ASSERT(fc);
 918         BT_LIB_LOGD("Destroying variant field class object: %!+F", fc);
 919         finalize_named_field_classes_container((void *) fc);
 920         BT_LOGD_STR("Putting selector field path.");
 921         BT_OBJECT_PUT_REF_AND_RESET(fc->selector_field_path);
 922         BT_LOGD_STR("Putting selector field class.");
 923         BT_OBJECT_PUT_REF_AND_RESET(fc->selector_fc);
 924         g_free(fc);
 925 }
 926
 927 struct bt_field_class *bt_field_class_variant_create(
 928                 bt_trace_class *trace_class)
 929 {
 930         int ret;
 931         struct bt_field_class_variant *var_fc = NULL;
 932
 933         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
 934         BT_LOGD_STR("Creating default variant field class object.");
 935         var_fc = g_new0(struct bt_field_class_variant, 1);
 936         if (!var_fc) {
 937                 BT_LIB_LOGE_APPEND_CAUSE(
 938                         "Failed to allocate one variant field class.");
 939                 goto error;
 940         }
 941
 942         ret = init_named_field_classes_container((void *) var_fc,
 943                 BT_FIELD_CLASS_TYPE_VARIANT, destroy_variant_field_class);
 944         if (ret) {
 945                 goto error;
 946         }
 947
 948         BT_LIB_LOGD("Created variant field class object: %!+F", var_fc);
 949         goto end;
 950
 951 error:
 952         BT_OBJECT_PUT_REF_AND_RESET(var_fc);
 953
 954 end:
 955         return (void *) var_fc;
 956 }
 957
 958 enum bt_field_class_variant_set_selector_field_class_status
 959 bt_field_class_variant_set_selector_field_class(
 960                 struct bt_field_class *fc,
 961                 struct bt_field_class *selector_fc)
 962 {
 963         struct bt_field_class_variant *var_fc = (void *) fc;
 964
 965         BT_ASSERT_PRE_NON_NULL(fc, "Variant field class");
 966         BT_ASSERT_PRE_NON_NULL(selector_fc, "Selector field class");
 967         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT, "Field class");
 968         BT_ASSERT_PRE_FC_IS_ENUM(selector_fc, "Selector field class");
 969         BT_ASSERT_PRE_DEV_FC_HOT(fc, "Variant field class");
 970         var_fc->selector_fc = selector_fc;
 971         bt_object_get_no_null_check(selector_fc);
 972         bt_field_class_freeze(selector_fc);
 973         return BT_FUNC_STATUS_OK;
 974 }
 975
 976 enum bt_field_class_variant_append_option_status
 977 bt_field_class_variant_append_option(
 978                 struct bt_field_class *fc,
 979                 const char *name, struct bt_field_class *option_fc)
 980 {
 981
 982         BT_ASSERT_PRE_NON_NULL(fc, "Field class");
 983         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT, "Field class");
 984         return append_named_field_class_to_container_field_class((void *) fc,
 985                 name, option_fc);
 986 }
 987
 988 const struct bt_field_class_variant_option *
 989 bt_field_class_variant_borrow_option_by_name_const(
 990                 const struct bt_field_class *fc, const char *name)
 991 {
 992         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
 993         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT,
 994                 "Field class");
 995         return (const void *)
 996                 borrow_named_field_class_from_container_field_class_by_name(
 997                         (void *) fc, name);
 998 }
 999
1000 struct bt_field_class_variant_option *
1001 bt_field_class_variant_borrow_option_by_name(
1002                 struct bt_field_class *fc, const char *name)
1003 {
1004         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1005         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT, "Field class");
1006         return (void *)
1007                 borrow_named_field_class_from_container_field_class_by_name(
1008                         (void *) fc, name);
1009 }
1010
1011 uint64_t bt_field_class_variant_get_option_count(const struct bt_field_class *fc)
1012 {
1013         const struct bt_field_class_variant *var_fc = (const void *) fc;
1014
1015         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1016         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT, "Field class");
1017         return (uint64_t) var_fc->common.named_fcs->len;
1018 }
1019
1020 const struct bt_field_class_variant_option *
1021 bt_field_class_variant_borrow_option_by_index_const(
1022                 const struct bt_field_class *fc, uint64_t index)
1023 {
1024         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1025         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT, "Field class");
1026         return (const void *)
1027                 borrow_named_field_class_from_container_field_class_at_index(
1028                         (void *) fc, index);
1029 }
1030
1031 struct bt_field_class_variant_option *
1032 bt_field_class_variant_borrow_option_by_index(
1033                 struct bt_field_class *fc, uint64_t index)
1034 {
1035         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1036         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT, "Field class");
1037         return (void *)
1038                 borrow_named_field_class_from_container_field_class_at_index(
1039                         (void *) fc, index);
1040 }
1041
1042 const char *bt_field_class_variant_option_get_name(
1043                 const struct bt_field_class_variant_option *option)
1044 {
1045         const struct bt_named_field_class *named_fc = (const void *) option;
1046
1047         BT_ASSERT_PRE_DEV_NON_NULL(option, "Variant field class option");
1048         return named_fc->name->str;
1049 }
1050
1051 const struct bt_field_class *
1052 bt_field_class_variant_option_borrow_field_class_const(
1053                 const struct bt_field_class_variant_option *option)
1054 {
1055         const struct bt_named_field_class *named_fc = (const void *) option;
1056
1057         BT_ASSERT_PRE_DEV_NON_NULL(option, "Variant field class option");
1058         return named_fc->fc;
1059 }
1060
1061 struct bt_field_class *
1062 bt_field_class_variant_option_borrow_field_class(
1063                 struct bt_field_class_variant_option *option)
1064 {
1065         struct bt_named_field_class *named_fc = (void *) option;
1066
1067         BT_ASSERT_PRE_DEV_NON_NULL(option, "Variant field class option");
1068         return named_fc->fc;
1069 }
1070
1071 const struct bt_field_path *
1072 bt_field_class_variant_borrow_selector_field_path_const(
1073                 const struct bt_field_class *fc)
1074 {
1075         const struct bt_field_class_variant *var_fc = (const void *) fc;
1076
1077         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1078         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_VARIANT,
1079                 "Field class");
1080         return var_fc->selector_field_path;
1081 }
1082
1083 static
1084 void init_array_field_class(struct bt_field_class_array *fc,
1085                 enum bt_field_class_type type, bt_object_release_func release_func,
1086                 struct bt_field_class *element_fc)
1087 {
1088         BT_ASSERT(element_fc);
1089         init_field_class((void *) fc, type, release_func);
1090         fc->element_fc = element_fc;
1091         bt_object_get_no_null_check(element_fc);
1092         bt_field_class_freeze(element_fc);
1093 }
1094
1095 static
1096 void finalize_array_field_class(struct bt_field_class_array *array_fc)
1097 {
1098         BT_ASSERT(array_fc);
1099         BT_LOGD_STR("Putting element field class.");
1100         BT_OBJECT_PUT_REF_AND_RESET(array_fc->element_fc);
1101 }
1102
1103 static
1104 void destroy_static_array_field_class(struct bt_object *obj)
1105 {
1106         BT_ASSERT(obj);
1107         BT_LIB_LOGD("Destroying static array field class object: %!+F", obj);
1108         finalize_array_field_class((void *) obj);
1109         g_free(obj);
1110 }
1111
1112 struct bt_field_class *
1113 bt_field_class_static_array_create(bt_trace_class *trace_class,
1114                 struct bt_field_class *element_fc, uint64_t length)
1115 {
1116         struct bt_field_class_static_array *array_fc = NULL;
1117
1118         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
1119         BT_ASSERT_PRE_NON_NULL(element_fc, "Element field class");
1120         BT_LOGD_STR("Creating default static array field class object.");
1121         array_fc = g_new0(struct bt_field_class_static_array, 1);
1122         if (!array_fc) {
1123                 BT_LIB_LOGE_APPEND_CAUSE(
1124                         "Failed to allocate one static array field class.");
1125                 goto error;
1126         }
1127
1128         init_array_field_class((void *) array_fc, BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
1129                 destroy_static_array_field_class, element_fc);
1130         array_fc->length = length;
1131         BT_LIB_LOGD("Created static array field class object: %!+F", array_fc);
1132         goto end;
1133
1134 error:
1135         BT_OBJECT_PUT_REF_AND_RESET(array_fc);
1136
1137 end:
1138         return (void *) array_fc;
1139 }
1140
1141 const struct bt_field_class *
1142 bt_field_class_array_borrow_element_field_class_const(
1143                 const struct bt_field_class *fc)
1144 {
1145         const struct bt_field_class_array *array_fc = (const void *) fc;
1146
1147         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1148         BT_ASSERT_PRE_DEV_FC_IS_ARRAY(fc, "Field class");
1149         return array_fc->element_fc;
1150 }
1151
1152 struct bt_field_class *
1153 bt_field_class_array_borrow_element_field_class(struct bt_field_class *fc)
1154 {
1155         struct bt_field_class_array *array_fc = (void *) fc;
1156
1157         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1158         BT_ASSERT_PRE_DEV_FC_IS_ARRAY(fc, "Field class");
1159         return array_fc->element_fc;
1160 }
1161
1162 uint64_t bt_field_class_static_array_get_length(const struct bt_field_class *fc)
1163 {
1164         const struct bt_field_class_static_array *array_fc = (const void *) fc;
1165
1166         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1167         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
1168                 "Field class");
1169         return (uint64_t) array_fc->length;
1170 }
1171
1172 static
1173 void destroy_dynamic_array_field_class(struct bt_object *obj)
1174 {
1175         struct bt_field_class_dynamic_array *fc = (void *) obj;
1176
1177         BT_ASSERT(fc);
1178         BT_LIB_LOGD("Destroying dynamic array field class object: %!+F", fc);
1179         finalize_array_field_class((void *) fc);
1180         BT_LOGD_STR("Putting length field path.");
1181         BT_OBJECT_PUT_REF_AND_RESET(fc->length_field_path);
1182         BT_LOGD_STR("Putting length field class.");
1183         BT_OBJECT_PUT_REF_AND_RESET(fc->length_fc);
1184         g_free(fc);
1185 }
1186
1187 struct bt_field_class *bt_field_class_dynamic_array_create(
1188                 bt_trace_class *trace_class,
1189                 struct bt_field_class *element_fc)
1190 {
1191         struct bt_field_class_dynamic_array *array_fc = NULL;
1192
1193         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
1194         BT_ASSERT_PRE_NON_NULL(element_fc, "Element field class");
1195         BT_LOGD_STR("Creating default dynamic array field class object.");
1196         array_fc = g_new0(struct bt_field_class_dynamic_array, 1);
1197         if (!array_fc) {
1198                 BT_LIB_LOGE_APPEND_CAUSE(
1199                         "Failed to allocate one dynamic array field class.");
1200                 goto error;
1201         }
1202
1203         init_array_field_class((void *) array_fc,
1204                 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY,
1205                 destroy_dynamic_array_field_class, element_fc);
1206         BT_LIB_LOGD("Created dynamic array field class object: %!+F", array_fc);
1207         goto end;
1208
1209 error:
1210         BT_OBJECT_PUT_REF_AND_RESET(array_fc);
1211
1212 end:
1213         return (void *) array_fc;
1214 }
1215
1216 enum bt_field_class_dynamic_array_set_length_field_class_status
1217 bt_field_class_dynamic_array_set_length_field_class(
1218                 struct bt_field_class *fc,
1219                 struct bt_field_class *length_fc)
1220 {
1221         struct bt_field_class_dynamic_array *array_fc = (void *) fc;
1222
1223         BT_ASSERT_PRE_NON_NULL(fc, "Dynamic array field class");
1224         BT_ASSERT_PRE_NON_NULL(length_fc, "Length field class");
1225         BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY,
1226                 "Field class");
1227         BT_ASSERT_PRE_FC_IS_UNSIGNED_INT(length_fc, "Length field class");
1228         BT_ASSERT_PRE_DEV_FC_HOT(fc, "Dynamic array field class");
1229         array_fc->length_fc = length_fc;
1230         bt_object_get_no_null_check(length_fc);
1231         bt_field_class_freeze(length_fc);
1232         return BT_FUNC_STATUS_OK;
1233 }
1234
1235 const struct bt_field_path *
1236 bt_field_class_dynamic_array_borrow_length_field_path_const(
1237                 const struct bt_field_class *fc)
1238 {
1239         const struct bt_field_class_dynamic_array *seq_fc = (const void *) fc;
1240
1241         BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
1242         BT_ASSERT_PRE_DEV_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY,
1243                 "Field class");
1244         return seq_fc->length_field_path;
1245 }
1246
1247 static
1248 void destroy_string_field_class(struct bt_object *obj)
1249 {
1250         BT_ASSERT(obj);
1251         BT_LIB_LOGD("Destroying string field class object: %!+F", obj);
1252         g_free(obj);
1253 }
1254
1255 struct bt_field_class *bt_field_class_string_create(bt_trace_class *trace_class)
1256 {
1257         struct bt_field_class_string *string_fc = NULL;
1258
1259         BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
1260         BT_LOGD_STR("Creating default string field class object.");
1261         string_fc = g_new0(struct bt_field_class_string, 1);
1262         if (!string_fc) {
1263                 BT_LIB_LOGE_APPEND_CAUSE(
1264                         "Failed to allocate one string field class.");
1265                 goto error;
1266         }
1267
1268         init_field_class((void *) string_fc, BT_FIELD_CLASS_TYPE_STRING,
1269                 destroy_string_field_class);
1270         BT_LIB_LOGD("Created string field class object: %!+F", string_fc);
1271         goto end;
1272
1273 error:
1274         BT_OBJECT_PUT_REF_AND_RESET(string_fc);
1275
1276 end:
1277         return (void *) string_fc;
1278 }
1279
1280 BT_HIDDEN
1281 void _bt_field_class_freeze(const struct bt_field_class *c_fc)
1282 {
1283         struct bt_field_class *fc = (void *) c_fc;
1284
1285         /*
1286          * Element/member/option field classes are frozen when added to
1287          * their owner.
1288          */
1289         BT_ASSERT(fc);
1290         fc->frozen = true;
1291
1292         switch (fc->type) {
1293         case BT_FIELD_CLASS_TYPE_STRUCTURE:
1294         case BT_FIELD_CLASS_TYPE_VARIANT:
1295         {
1296                 struct bt_field_class_named_field_class_container *container_fc =
1297                         (void *) fc;
1298                 uint64_t i;
1299
1300                 for (i = 0; i < container_fc->named_fcs->len; i++) {
1301                         struct bt_named_field_class *named_fc =
1302                                 BT_FIELD_CLASS_NAMED_FC_AT_INDEX(
1303                                         container_fc, i);
1304
1305                         bt_named_field_class_freeze(named_fc);
1306                 }
1307
1308                 break;
1309         }
1310         default:
1311                 break;
1312         }
1313 }
1314
1315 BT_HIDDEN
1316 void _bt_named_field_class_freeze(const struct bt_named_field_class *named_fc)
1317 {
1318         BT_ASSERT(named_fc);
1319         ((struct bt_named_field_class *) named_fc)->frozen = true;
1320         bt_field_class_freeze(named_fc->fc);
1321 }
1322
1323 BT_HIDDEN
1324 void bt_field_class_make_part_of_trace_class(const struct bt_field_class *c_fc)
1325 {
1326         struct bt_field_class *fc = (void *) c_fc;
1327
1328         BT_ASSERT(fc);
1329         BT_ASSERT_PRE(!fc->part_of_trace_class,
1330                 "Field class is already part of a trace: %!+F", fc);
1331         fc->part_of_trace_class = true;
1332
1333         switch (fc->type) {
1334         case BT_FIELD_CLASS_TYPE_STRUCTURE:
1335         case BT_FIELD_CLASS_TYPE_VARIANT:
1336         {
1337                 struct bt_field_class_named_field_class_container *container_fc =
1338                         (void *) fc;
1339                 uint64_t i;
1340
1341                 for (i = 0; i < container_fc->named_fcs->len; i++) {
1342                         struct bt_named_field_class *named_fc =
1343                                 BT_FIELD_CLASS_NAMED_FC_AT_INDEX(
1344                                         container_fc, i);
1345
1346                         bt_field_class_make_part_of_trace_class(named_fc->fc);
1347                 }
1348
1349                 break;
1350         }
1351         case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
1352         case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
1353         {
1354                 struct bt_field_class_array *array_fc = (void *) fc;
1355
1356                 bt_field_class_make_part_of_trace_class(array_fc->element_fc);
1357                 break;
1358         }
1359         default:
1360                 break;
1361         }
1362 }
1363
1364 void bt_field_class_get_ref(const struct bt_field_class *field_class)
1365 {
1366         bt_object_get_ref(field_class);
1367 }
1368
1369 void bt_field_class_put_ref(const struct bt_field_class *field_class)
1370 {
1371         bt_object_put_ref(field_class);
1372 }