src/plugins/ctf/fs-sink/fs-sink-ctf-meta.h

   1 #ifndef BABELTRACE_PLUGIN_CTF_FS_SINK_FS_SINK_CTF_META_H
   2 #define BABELTRACE_PLUGIN_CTF_FS_SINK_FS_SINK_CTF_META_H
   3
   4 /*
   5  * Copyright 2018-2019 - Philippe Proulx <pproulx@efficios.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  */
  17
  18 #include <babeltrace2/babeltrace.h>
  19 #include "common/common.h"
  20 #include "common/assert.h"
  21 #include "common/uuid.h"
  22 #include <glib.h>
  23 #include <stdint.h>
  24 #include <string.h>
  25 #include <stdbool.h>
  26 #include <ctype.h>
  27
  28 enum fs_sink_ctf_field_class_type {
  29         FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL,
  30         FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY,
  31         FS_SINK_CTF_FIELD_CLASS_TYPE_INT,
  32         FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT,
  33         FS_SINK_CTF_FIELD_CLASS_TYPE_STRING,
  34         FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT,
  35         FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY,
  36         FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE,
  37         FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION,
  38         FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT,
  39 };
  40
  41 struct fs_sink_ctf_field_class {
  42         enum fs_sink_ctf_field_class_type type;
  43
  44         /* Weak */
  45         const bt_field_class *ir_fc;
  46
  47         unsigned int alignment;
  48
  49         /* Index of the field class within its own parent */
  50         uint64_t index_in_parent;
  51 };
  52
  53 struct fs_sink_ctf_field_class_bit_array {
  54         struct fs_sink_ctf_field_class base;
  55         unsigned int size;
  56 };
  57
  58 struct fs_sink_ctf_field_class_bool {
  59         struct fs_sink_ctf_field_class_bit_array base;
  60 };
  61
  62 struct fs_sink_ctf_field_class_int {
  63         struct fs_sink_ctf_field_class_bit_array base;
  64         bool is_signed;
  65 };
  66
  67 struct fs_sink_ctf_field_class_float {
  68         struct fs_sink_ctf_field_class_bit_array base;
  69 };
  70
  71 struct fs_sink_ctf_field_class_string {
  72         struct fs_sink_ctf_field_class base;
  73 };
  74
  75 struct fs_sink_ctf_named_field_class {
  76         GString *name;
  77
  78         /* Owned by this */
  79         struct fs_sink_ctf_field_class *fc;
  80 };
  81
  82 struct fs_sink_ctf_field_class_struct {
  83         struct fs_sink_ctf_field_class base;
  84
  85         /* Array of `struct fs_sink_ctf_named_field_class` */
  86         GArray *members;
  87 };
  88
  89 struct fs_sink_ctf_field_class_option {
  90         struct fs_sink_ctf_field_class base;
  91         struct fs_sink_ctf_field_class *content_fc;
  92         GString *tag_ref;
  93 };
  94
  95 struct fs_sink_ctf_field_class_variant {
  96         struct fs_sink_ctf_field_class base;
  97         GString *tag_ref;
  98         bool tag_is_before;
  99
 100         /* Array of `struct fs_sink_ctf_named_field_class` */
 101         GArray *options;
 102 };
 103
 104 struct fs_sink_ctf_field_class_array_base {
 105         struct fs_sink_ctf_field_class base;
 106         struct fs_sink_ctf_field_class *elem_fc;
 107 };
 108
 109 struct fs_sink_ctf_field_class_array {
 110         struct fs_sink_ctf_field_class_array_base base;
 111         uint64_t length;
 112 };
 113
 114 struct fs_sink_ctf_field_class_sequence {
 115         struct fs_sink_ctf_field_class_array_base base;
 116         GString *length_ref;
 117         bool length_is_before;
 118 };
 119
 120 struct fs_sink_ctf_stream_class;
 121
 122 struct fs_sink_ctf_event_class {
 123         /* Weak */
 124         const bt_event_class *ir_ec;
 125
 126         /* Weak */
 127         struct fs_sink_ctf_stream_class *sc;
 128
 129         /* Owned by this */
 130         struct fs_sink_ctf_field_class *spec_context_fc;
 131
 132         /* Owned by this */
 133         struct fs_sink_ctf_field_class *payload_fc;
 134 };
 135
 136 struct fs_sink_ctf_trace;
 137
 138 struct fs_sink_ctf_stream_class {
 139         /* Weak */
 140         struct fs_sink_ctf_trace *trace;
 141
 142         /* Weak */
 143         const bt_stream_class *ir_sc;
 144
 145         /* Weak */
 146         const bt_clock_class *default_clock_class;
 147
 148         GString *default_clock_class_name;
 149         bool has_packets;
 150         bool packets_have_ts_begin;
 151         bool packets_have_ts_end;
 152         bool has_discarded_events;
 153         bool discarded_events_has_ts;
 154         bool discarded_packets_has_ts;
 155
 156         /* Owned by this */
 157         struct fs_sink_ctf_field_class *packet_context_fc;
 158
 159         /* Owned by this */
 160         struct fs_sink_ctf_field_class *event_common_context_fc;
 161
 162         /* Array of `struct fs_sink_ctf_event_class *` (owned by this) */
 163         GPtrArray *event_classes;
 164
 165         /*
 166          * `const bt_event_class *` (weak) ->
 167          * `struct fs_sink_ctf_event_class *` (weak)
 168          */
 169         GHashTable *event_classes_from_ir;
 170 };
 171
 172 struct fs_sink_ctf_trace {
 173         /* Weak */
 174         const bt_trace *ir_trace;
 175
 176         /* Weak */
 177         const bt_trace_class *ir_tc;
 178
 179         bt_uuid_t uuid;
 180
 181         /* Array of `struct fs_sink_ctf_stream_class *` (owned by this) */
 182         GPtrArray *stream_classes;
 183 };
 184
 185 static inline
 186 void fs_sink_ctf_field_class_destroy(struct fs_sink_ctf_field_class *fc);
 187
 188 static inline
 189 void _fs_sink_ctf_field_class_init(struct fs_sink_ctf_field_class *fc,
 190                 enum fs_sink_ctf_field_class_type type,
 191                 const bt_field_class *ir_fc, unsigned int alignment,
 192                 uint64_t index_in_parent)
 193 {
 194         BT_ASSERT(fc);
 195         fc->type = type;
 196         fc->ir_fc = ir_fc;
 197         fc->alignment = alignment;
 198         fc->index_in_parent = index_in_parent;
 199 }
 200
 201 static inline
 202 void _fs_sink_ctf_field_class_bit_array_init(
 203                 struct fs_sink_ctf_field_class_bit_array *fc,
 204                 enum fs_sink_ctf_field_class_type type,
 205                 const bt_field_class *ir_fc, unsigned int size,
 206                 uint64_t index_in_parent)
 207 {
 208         _fs_sink_ctf_field_class_init((void *) fc, type, ir_fc,
 209                 size % 8 == 0 ? 8 : 1, index_in_parent);
 210         fc->size = size;
 211 }
 212
 213 static inline
 214 void _fs_sink_ctf_field_class_int_init(struct fs_sink_ctf_field_class_int *fc,
 215                 enum fs_sink_ctf_field_class_type type,
 216                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 217 {
 218         bt_field_class_type ir_fc_type = bt_field_class_get_type(ir_fc);
 219
 220         _fs_sink_ctf_field_class_bit_array_init((void *) fc, type, ir_fc,
 221                 (unsigned int) bt_field_class_integer_get_field_value_range(
 222                         ir_fc),
 223                 index_in_parent);
 224         fc->is_signed = bt_field_class_type_is(ir_fc_type,
 225                 BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
 226 }
 227
 228 static inline
 229 void _fs_sink_ctf_named_field_class_init(
 230                 struct fs_sink_ctf_named_field_class *named_fc)
 231 {
 232         BT_ASSERT(named_fc);
 233         named_fc->name = g_string_new(NULL);
 234         BT_ASSERT(named_fc->name);
 235 }
 236
 237 static inline
 238 void _fs_sink_ctf_named_field_class_fini(
 239                 struct fs_sink_ctf_named_field_class *named_fc)
 240 {
 241         BT_ASSERT(named_fc);
 242
 243         if (named_fc->name) {
 244                 g_string_free(named_fc->name, TRUE);
 245                 named_fc->name = NULL;
 246         }
 247
 248         fs_sink_ctf_field_class_destroy(named_fc->fc);
 249         named_fc->fc = NULL;
 250 }
 251
 252 static inline
 253 struct fs_sink_ctf_field_class_bit_array *
 254 fs_sink_ctf_field_class_bit_array_create(
 255                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 256 {
 257         struct fs_sink_ctf_field_class_bit_array *fc =
 258                 g_new0(struct fs_sink_ctf_field_class_bit_array, 1);
 259
 260         BT_ASSERT(fc);
 261         _fs_sink_ctf_field_class_bit_array_init((void *) fc,
 262                 FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY, ir_fc,
 263                 (unsigned int) bt_field_class_bit_array_get_length(ir_fc),
 264                 index_in_parent);
 265         return fc;
 266 }
 267
 268 static inline
 269 struct fs_sink_ctf_field_class_bool *fs_sink_ctf_field_class_bool_create(
 270                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 271 {
 272         struct fs_sink_ctf_field_class_bool *fc =
 273                 g_new0(struct fs_sink_ctf_field_class_bool, 1);
 274
 275         BT_ASSERT(fc);
 276
 277         /*
 278          * CTF 1.8 has no boolean field class type, so this component
 279          * translates it to an 8-bit unsigned integer field class.
 280          */
 281         _fs_sink_ctf_field_class_bit_array_init((void *) fc,
 282                 FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL, ir_fc,
 283                 8, index_in_parent);
 284         return fc;
 285 }
 286
 287 static inline
 288 struct fs_sink_ctf_field_class_int *fs_sink_ctf_field_class_int_create(
 289                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 290 {
 291         struct fs_sink_ctf_field_class_int *fc =
 292                 g_new0(struct fs_sink_ctf_field_class_int, 1);
 293
 294         BT_ASSERT(fc);
 295         _fs_sink_ctf_field_class_int_init(fc, FS_SINK_CTF_FIELD_CLASS_TYPE_INT,
 296                 ir_fc, index_in_parent);
 297         return fc;
 298 }
 299
 300 static inline
 301 struct fs_sink_ctf_field_class_float *fs_sink_ctf_field_class_float_create(
 302                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 303 {
 304         struct fs_sink_ctf_field_class_float *fc =
 305                 g_new0(struct fs_sink_ctf_field_class_float, 1);
 306
 307         BT_ASSERT(fc);
 308         _fs_sink_ctf_field_class_bit_array_init((void *) fc,
 309                 FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT,
 310                 ir_fc,
 311                 bt_field_class_get_type(ir_fc) ==
 312                         BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL ? 32 : 64,
 313                 index_in_parent);
 314         return fc;
 315 }
 316
 317 static inline
 318 struct fs_sink_ctf_field_class_string *fs_sink_ctf_field_class_string_create(
 319                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 320 {
 321         struct fs_sink_ctf_field_class_string *fc =
 322                 g_new0(struct fs_sink_ctf_field_class_string, 1);
 323
 324         BT_ASSERT(fc);
 325         _fs_sink_ctf_field_class_init((void *) fc,
 326                 FS_SINK_CTF_FIELD_CLASS_TYPE_STRING, ir_fc,
 327                 8, index_in_parent);
 328         return fc;
 329 }
 330
 331 static inline
 332 struct fs_sink_ctf_field_class_struct *fs_sink_ctf_field_class_struct_create_empty(
 333                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 334 {
 335         struct fs_sink_ctf_field_class_struct *fc =
 336                 g_new0(struct fs_sink_ctf_field_class_struct, 1);
 337
 338         BT_ASSERT(fc);
 339         _fs_sink_ctf_field_class_init((void *) fc,
 340                 FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT, ir_fc, 1, index_in_parent);
 341         fc->members = g_array_new(FALSE, TRUE,
 342                 sizeof(struct fs_sink_ctf_named_field_class));
 343         BT_ASSERT(fc->members);
 344         return fc;
 345 }
 346
 347 static inline
 348 struct fs_sink_ctf_field_class_option *fs_sink_ctf_field_class_option_create_empty(
 349                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 350 {
 351         struct fs_sink_ctf_field_class_option *fc =
 352                 g_new0(struct fs_sink_ctf_field_class_option, 1);
 353
 354         BT_ASSERT(fc);
 355         _fs_sink_ctf_field_class_init((void *) fc,
 356                 FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION, ir_fc,
 357                 1, index_in_parent);
 358         fc->tag_ref = g_string_new(NULL);
 359         BT_ASSERT(fc->tag_ref);
 360         return fc;
 361 }
 362
 363 static inline
 364 struct fs_sink_ctf_field_class_variant *fs_sink_ctf_field_class_variant_create_empty(
 365                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 366 {
 367         struct fs_sink_ctf_field_class_variant *fc =
 368                 g_new0(struct fs_sink_ctf_field_class_variant, 1);
 369
 370         BT_ASSERT(fc);
 371         _fs_sink_ctf_field_class_init((void *) fc,
 372                 FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT, ir_fc,
 373                 1, index_in_parent);
 374         fc->options = g_array_new(FALSE, TRUE,
 375                 sizeof(struct fs_sink_ctf_named_field_class));
 376         BT_ASSERT(fc->options);
 377         fc->tag_ref = g_string_new(NULL);
 378         BT_ASSERT(fc->tag_ref);
 379         fc->tag_is_before =
 380                 bt_field_class_get_type(fc->base.ir_fc) ==
 381                 BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD;
 382         return fc;
 383 }
 384
 385 static inline
 386 struct fs_sink_ctf_field_class_array *fs_sink_ctf_field_class_array_create_empty(
 387                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 388 {
 389         struct fs_sink_ctf_field_class_array *fc =
 390                 g_new0(struct fs_sink_ctf_field_class_array, 1);
 391
 392         BT_ASSERT(fc);
 393         _fs_sink_ctf_field_class_init((void *) fc,
 394                 FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY, ir_fc,
 395                 1, index_in_parent);
 396         fc->length = bt_field_class_array_static_get_length(ir_fc);
 397         return fc;
 398 }
 399
 400 static inline
 401 struct fs_sink_ctf_field_class_sequence *fs_sink_ctf_field_class_sequence_create_empty(
 402                 const bt_field_class *ir_fc, uint64_t index_in_parent)
 403 {
 404         struct fs_sink_ctf_field_class_sequence *fc =
 405                 g_new0(struct fs_sink_ctf_field_class_sequence, 1);
 406
 407         BT_ASSERT(fc);
 408         _fs_sink_ctf_field_class_init((void *) fc,
 409                 FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE,
 410                 ir_fc, 1, index_in_parent);
 411         fc->length_ref = g_string_new(NULL);
 412         BT_ASSERT(fc->length_ref);
 413         fc->length_is_before =
 414                 bt_field_class_get_type(ir_fc) ==
 415                         BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD;
 416         return fc;
 417 }
 418
 419 static inline
 420 struct fs_sink_ctf_named_field_class *
 421 fs_sink_ctf_field_class_struct_borrow_member_by_index(
 422                 struct fs_sink_ctf_field_class_struct *fc, uint64_t index);
 423
 424 static inline
 425 struct fs_sink_ctf_named_field_class *
 426 fs_sink_ctf_field_class_variant_borrow_option_by_index(
 427                 struct fs_sink_ctf_field_class_variant *fc, uint64_t index);
 428
 429 static inline
 430 void _fs_sink_ctf_field_class_fini(struct fs_sink_ctf_field_class *fc)
 431 {
 432         BT_ASSERT(fc);
 433 }
 434
 435 static inline
 436 void _fs_sink_ctf_field_class_bit_array_destroy(
 437                 struct fs_sink_ctf_field_class_int *fc)
 438 {
 439         BT_ASSERT(fc);
 440         _fs_sink_ctf_field_class_fini((void *) fc);
 441         g_free(fc);
 442 }
 443
 444 static inline
 445 void _fs_sink_ctf_field_class_bool_destroy(
 446                 struct fs_sink_ctf_field_class_int *fc)
 447 {
 448         BT_ASSERT(fc);
 449         _fs_sink_ctf_field_class_fini((void *) fc);
 450         g_free(fc);
 451 }
 452
 453 static inline
 454 void _fs_sink_ctf_field_class_int_destroy(
 455                 struct fs_sink_ctf_field_class_int *fc)
 456 {
 457         BT_ASSERT(fc);
 458         _fs_sink_ctf_field_class_fini((void *) fc);
 459         g_free(fc);
 460 }
 461
 462 static inline
 463 void _fs_sink_ctf_field_class_float_destroy(
 464                 struct fs_sink_ctf_field_class_float *fc)
 465 {
 466         BT_ASSERT(fc);
 467         _fs_sink_ctf_field_class_fini((void *) fc);
 468         g_free(fc);
 469 }
 470
 471 static inline
 472 void _fs_sink_ctf_field_class_string_destroy(
 473                 struct fs_sink_ctf_field_class_string *fc)
 474 {
 475         BT_ASSERT(fc);
 476         _fs_sink_ctf_field_class_fini((void *) fc);
 477         g_free(fc);
 478 }
 479
 480 static inline
 481 void _fs_sink_ctf_field_class_struct_destroy(
 482                 struct fs_sink_ctf_field_class_struct *fc)
 483 {
 484         BT_ASSERT(fc);
 485         _fs_sink_ctf_field_class_fini((void *) fc);
 486
 487         if (fc->members) {
 488                 uint64_t i;
 489
 490                 for (i = 0; i < fc->members->len; i++) {
 491                         struct fs_sink_ctf_named_field_class *named_fc =
 492                                 fs_sink_ctf_field_class_struct_borrow_member_by_index(
 493                                         fc, i);
 494
 495                         _fs_sink_ctf_named_field_class_fini(named_fc);
 496                 }
 497
 498                 g_array_free(fc->members, TRUE);
 499                 fc->members = NULL;
 500         }
 501
 502         g_free(fc);
 503 }
 504
 505 static inline
 506 void _fs_sink_ctf_field_class_array_base_fini(
 507                 struct fs_sink_ctf_field_class_array_base *fc)
 508 {
 509         BT_ASSERT(fc);
 510         _fs_sink_ctf_field_class_fini((void *) fc);
 511         fs_sink_ctf_field_class_destroy(fc->elem_fc);
 512         fc->elem_fc = NULL;
 513 }
 514
 515 static inline
 516 void _fs_sink_ctf_field_class_array_destroy(
 517                 struct fs_sink_ctf_field_class_array *fc)
 518 {
 519         BT_ASSERT(fc);
 520         _fs_sink_ctf_field_class_array_base_fini((void *) fc);
 521         g_free(fc);
 522 }
 523
 524 static inline
 525 void _fs_sink_ctf_field_class_sequence_destroy(
 526                 struct fs_sink_ctf_field_class_sequence *fc)
 527 {
 528         BT_ASSERT(fc);
 529         _fs_sink_ctf_field_class_array_base_fini((void *) fc);
 530
 531         if (fc->length_ref) {
 532                 g_string_free(fc->length_ref, TRUE);
 533                 fc->length_ref = NULL;
 534         }
 535
 536         g_free(fc);
 537 }
 538
 539 static inline
 540 void _fs_sink_ctf_field_class_option_destroy(
 541                 struct fs_sink_ctf_field_class_option *fc)
 542 {
 543         BT_ASSERT(fc);
 544         _fs_sink_ctf_field_class_fini((void *) fc);
 545         fs_sink_ctf_field_class_destroy(fc->content_fc);
 546
 547         if (fc->tag_ref) {
 548                 g_string_free(fc->tag_ref, TRUE);
 549                 fc->tag_ref = NULL;
 550         }
 551
 552         g_free(fc);
 553 }
 554
 555 static inline
 556 void _fs_sink_ctf_field_class_variant_destroy(
 557                 struct fs_sink_ctf_field_class_variant *fc)
 558 {
 559         BT_ASSERT(fc);
 560         _fs_sink_ctf_field_class_fini((void *) fc);
 561
 562         if (fc->options) {
 563                 uint64_t i;
 564
 565                 for (i = 0; i < fc->options->len; i++) {
 566                         struct fs_sink_ctf_named_field_class *named_fc =
 567                                 fs_sink_ctf_field_class_variant_borrow_option_by_index(
 568                                         fc, i);
 569
 570                         _fs_sink_ctf_named_field_class_fini(named_fc);
 571                 }
 572
 573                 g_array_free(fc->options, TRUE);
 574                 fc->options = NULL;
 575         }
 576
 577         if (fc->tag_ref) {
 578                 g_string_free(fc->tag_ref, TRUE);
 579                 fc->tag_ref = NULL;
 580         }
 581
 582         g_free(fc);
 583 }
 584
 585 static inline
 586 void fs_sink_ctf_field_class_destroy(struct fs_sink_ctf_field_class *fc)
 587 {
 588         if (!fc) {
 589                 return;
 590         }
 591
 592         switch (fc->type) {
 593         case FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL:
 594                 _fs_sink_ctf_field_class_bool_destroy((void *) fc);
 595                 break;
 596         case FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY:
 597                 _fs_sink_ctf_field_class_bit_array_destroy((void *) fc);
 598                 break;
 599         case FS_SINK_CTF_FIELD_CLASS_TYPE_INT:
 600                 _fs_sink_ctf_field_class_int_destroy((void *) fc);
 601                 break;
 602         case FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT:
 603                 _fs_sink_ctf_field_class_float_destroy((void *) fc);
 604                 break;
 605         case FS_SINK_CTF_FIELD_CLASS_TYPE_STRING:
 606                 _fs_sink_ctf_field_class_string_destroy((void *) fc);
 607                 break;
 608         case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT:
 609                 _fs_sink_ctf_field_class_struct_destroy((void *) fc);
 610                 break;
 611         case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY:
 612                 _fs_sink_ctf_field_class_array_destroy((void *) fc);
 613                 break;
 614         case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
 615                 _fs_sink_ctf_field_class_sequence_destroy((void *) fc);
 616                 break;
 617         case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION:
 618                 _fs_sink_ctf_field_class_option_destroy((void *) fc);
 619                 break;
 620         case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
 621                 _fs_sink_ctf_field_class_variant_destroy((void *) fc);
 622                 break;
 623         default:
 624                 abort();
 625         }
 626 }
 627
 628 static inline
 629 struct fs_sink_ctf_named_field_class *
 630 fs_sink_ctf_field_class_struct_borrow_member_by_index(
 631                 struct fs_sink_ctf_field_class_struct *fc, uint64_t index)
 632 {
 633         BT_ASSERT_DBG(fc);
 634         BT_ASSERT_DBG(index < fc->members->len);
 635         return &g_array_index(fc->members, struct fs_sink_ctf_named_field_class,
 636                 index);
 637 }
 638
 639 static inline
 640 struct fs_sink_ctf_named_field_class *
 641 fs_sink_ctf_field_class_struct_borrow_member_by_name(
 642                 struct fs_sink_ctf_field_class_struct *fc, const char *name)
 643 {
 644         uint64_t i;
 645         struct fs_sink_ctf_named_field_class *ret_named_fc = NULL;
 646
 647         BT_ASSERT_DBG(fc);
 648         BT_ASSERT_DBG(name);
 649
 650         for (i = 0; i < fc->members->len; i++) {
 651                 struct fs_sink_ctf_named_field_class *named_fc =
 652                         fs_sink_ctf_field_class_struct_borrow_member_by_index(
 653                                 fc, i);
 654
 655                 if (strcmp(name, named_fc->name->str) == 0) {
 656                         ret_named_fc = named_fc;
 657                         goto end;
 658                 }
 659         }
 660
 661 end:
 662         return ret_named_fc;
 663 }
 664
 665 static inline
 666 struct fs_sink_ctf_field_class *
 667 fs_sink_ctf_field_class_struct_borrow_member_field_class_by_name(
 668                 struct fs_sink_ctf_field_class_struct *struct_fc, const char *name)
 669 {
 670         struct fs_sink_ctf_named_field_class *named_fc = NULL;
 671         struct fs_sink_ctf_field_class *fc = NULL;
 672
 673         if (!struct_fc) {
 674                 goto end;
 675         }
 676
 677         named_fc = fs_sink_ctf_field_class_struct_borrow_member_by_name(
 678                 struct_fc, name);
 679         if (!named_fc) {
 680                 goto end;
 681         }
 682
 683         fc = named_fc->fc;
 684
 685 end:
 686         return fc;
 687 }
 688
 689 static inline
 690 struct fs_sink_ctf_field_class_int *
 691 fs_sink_ctf_field_class_struct_borrow_member_int_field_class_by_name(
 692                 struct fs_sink_ctf_field_class_struct *struct_fc,
 693                 const char *name)
 694 {
 695         struct fs_sink_ctf_field_class_int *int_fc = NULL;
 696
 697         int_fc = (void *)
 698                 fs_sink_ctf_field_class_struct_borrow_member_field_class_by_name(
 699                         struct_fc, name);
 700         if (!int_fc) {
 701                 goto end;
 702         }
 703
 704         if (int_fc->base.base.type != FS_SINK_CTF_FIELD_CLASS_TYPE_INT) {
 705                 int_fc = NULL;
 706                 goto end;
 707         }
 708
 709 end:
 710         return int_fc;
 711 }
 712
 713 static inline
 714 void fs_sink_ctf_field_class_struct_align_at_least(
 715                 struct fs_sink_ctf_field_class_struct *fc,
 716                 unsigned int alignment)
 717 {
 718         if (alignment > fc->base.alignment) {
 719                 fc->base.alignment = alignment;
 720         }
 721 }
 722
 723 static inline
 724 void fs_sink_ctf_field_class_struct_append_member(
 725                 struct fs_sink_ctf_field_class_struct *fc,
 726                 const char *name, struct fs_sink_ctf_field_class *member_fc)
 727 {
 728         struct fs_sink_ctf_named_field_class *named_fc;
 729
 730         BT_ASSERT(fc);
 731         BT_ASSERT(name);
 732         g_array_set_size(fc->members, fc->members->len + 1);
 733
 734         named_fc = &g_array_index(fc->members,
 735                 struct fs_sink_ctf_named_field_class, fc->members->len - 1);
 736         _fs_sink_ctf_named_field_class_init(named_fc);
 737         g_string_assign(named_fc->name, name);
 738         named_fc->fc = member_fc;
 739         fs_sink_ctf_field_class_struct_align_at_least(fc, member_fc->alignment);
 740 }
 741
 742 static inline
 743 struct fs_sink_ctf_named_field_class *
 744 fs_sink_ctf_field_class_variant_borrow_option_by_index(
 745                 struct fs_sink_ctf_field_class_variant *fc, uint64_t index)
 746 {
 747         BT_ASSERT_DBG(fc);
 748         BT_ASSERT_DBG(index < fc->options->len);
 749         return &g_array_index(fc->options, struct fs_sink_ctf_named_field_class,
 750                 index);
 751 }
 752
 753 static inline
 754 struct fs_sink_ctf_named_field_class *
 755 fs_sink_ctf_field_class_variant_borrow_option_by_name(
 756                 struct fs_sink_ctf_field_class_variant *fc, const char *name)
 757 {
 758         uint64_t i;
 759         struct fs_sink_ctf_named_field_class *ret_named_fc = NULL;
 760
 761         BT_ASSERT_DBG(fc);
 762         BT_ASSERT_DBG(name);
 763
 764         for (i = 0; i < fc->options->len; i++) {
 765                 struct fs_sink_ctf_named_field_class *named_fc =
 766                         fs_sink_ctf_field_class_variant_borrow_option_by_index(
 767                                 fc, i);
 768
 769                 if (strcmp(name, named_fc->name->str) == 0) {
 770                         ret_named_fc = named_fc;
 771                         goto end;
 772                 }
 773         }
 774
 775 end:
 776         return ret_named_fc;
 777 }
 778
 779 static inline
 780 void fs_sink_ctf_field_class_variant_append_option(
 781                 struct fs_sink_ctf_field_class_variant *fc,
 782                 const char *name, struct fs_sink_ctf_field_class *option_fc)
 783 {
 784         struct fs_sink_ctf_named_field_class *named_fc;
 785
 786         BT_ASSERT(fc);
 787         BT_ASSERT(name);
 788         g_array_set_size(fc->options, fc->options->len + 1);
 789
 790         named_fc = &g_array_index(fc->options,
 791                 struct fs_sink_ctf_named_field_class, fc->options->len - 1);
 792         _fs_sink_ctf_named_field_class_init(named_fc);
 793         g_string_assign(named_fc->name, name);
 794         named_fc->fc = option_fc;
 795 }
 796
 797 static inline
 798 struct fs_sink_ctf_event_class *fs_sink_ctf_event_class_create(
 799                 struct fs_sink_ctf_stream_class *sc,
 800                 const bt_event_class *ir_ec)
 801 {
 802         struct fs_sink_ctf_event_class *ec =
 803                 g_new0(struct fs_sink_ctf_event_class, 1);
 804
 805         BT_ASSERT(sc);
 806         BT_ASSERT(ir_ec);
 807         BT_ASSERT(ec);
 808         ec->ir_ec = ir_ec;
 809         ec->sc = sc;
 810         g_ptr_array_add(sc->event_classes, ec);
 811         g_hash_table_insert(sc->event_classes_from_ir, (gpointer) ir_ec, ec);
 812         return ec;
 813 }
 814
 815 static inline
 816 void fs_sink_ctf_event_class_destroy(struct fs_sink_ctf_event_class *ec)
 817 {
 818         if (!ec) {
 819                 return;
 820         }
 821
 822         fs_sink_ctf_field_class_destroy(ec->spec_context_fc);
 823         ec->spec_context_fc = NULL;
 824         fs_sink_ctf_field_class_destroy(ec->payload_fc);
 825         ec->payload_fc = NULL;
 826         g_free(ec);
 827 }
 828
 829 static inline
 830 struct fs_sink_ctf_stream_class *fs_sink_ctf_stream_class_create(
 831                 struct fs_sink_ctf_trace *trace,
 832                 const bt_stream_class *ir_sc)
 833 {
 834         struct fs_sink_ctf_stream_class *sc =
 835                 g_new0(struct fs_sink_ctf_stream_class, 1);
 836
 837         BT_ASSERT(trace);
 838         BT_ASSERT(ir_sc);
 839         BT_ASSERT(sc);
 840         sc->trace = trace;
 841         sc->ir_sc = ir_sc;
 842         sc->default_clock_class =
 843                 bt_stream_class_borrow_default_clock_class_const(ir_sc);
 844         sc->default_clock_class_name = g_string_new(NULL);
 845         BT_ASSERT(sc->default_clock_class_name);
 846         sc->event_classes = g_ptr_array_new_with_free_func(
 847                 (GDestroyNotify) fs_sink_ctf_event_class_destroy);
 848         BT_ASSERT(sc->event_classes);
 849         sc->event_classes_from_ir = g_hash_table_new(g_direct_hash,
 850                 g_direct_equal);
 851         BT_ASSERT(sc->event_classes_from_ir);
 852         sc->has_packets = bt_stream_class_supports_packets(ir_sc);
 853         sc->packets_have_ts_begin =
 854                 bt_stream_class_packets_have_beginning_default_clock_snapshot(
 855                         ir_sc);
 856         sc->packets_have_ts_end =
 857                 bt_stream_class_packets_have_end_default_clock_snapshot(ir_sc);
 858         sc->has_discarded_events =
 859                 bt_stream_class_supports_discarded_events(ir_sc);
 860
 861         if (sc->has_discarded_events) {
 862                 sc->discarded_events_has_ts =
 863                         bt_stream_class_discarded_events_have_default_clock_snapshots(
 864                                 ir_sc);
 865         }
 866
 867         if (bt_stream_class_supports_discarded_packets(ir_sc)) {
 868                 sc->discarded_packets_has_ts =
 869                         bt_stream_class_discarded_packets_have_default_clock_snapshots(
 870                                 ir_sc);
 871         }
 872
 873         g_ptr_array_add(trace->stream_classes, sc);
 874         return sc;
 875 }
 876
 877 static inline
 878 void fs_sink_ctf_stream_class_destroy(struct fs_sink_ctf_stream_class *sc)
 879 {
 880         if (!sc) {
 881                 return;
 882         }
 883
 884         if (sc->default_clock_class_name) {
 885                 g_string_free(sc->default_clock_class_name, TRUE);
 886                 sc->default_clock_class_name = NULL;
 887         }
 888
 889         if (sc->event_classes) {
 890                 g_ptr_array_free(sc->event_classes, TRUE);
 891                 sc->event_classes = NULL;
 892         }
 893
 894         if (sc->event_classes_from_ir) {
 895                 g_hash_table_destroy(sc->event_classes_from_ir);
 896                 sc->event_classes_from_ir = NULL;
 897         }
 898
 899         fs_sink_ctf_field_class_destroy(sc->packet_context_fc);
 900         sc->packet_context_fc = NULL;
 901         fs_sink_ctf_field_class_destroy(sc->event_common_context_fc);
 902         sc->event_common_context_fc = NULL;
 903         g_free(sc);
 904 }
 905
 906 static inline
 907 void fs_sink_ctf_stream_class_append_event_class(
 908                 struct fs_sink_ctf_stream_class *sc,
 909                 struct fs_sink_ctf_event_class *ec)
 910 {
 911         g_ptr_array_add(sc->event_classes, ec);
 912 }
 913
 914 static inline
 915 void fs_sink_ctf_trace_destroy(struct fs_sink_ctf_trace *trace)
 916 {
 917         if (!trace) {
 918                 return;
 919         }
 920
 921         if (trace->stream_classes) {
 922                 g_ptr_array_free(trace->stream_classes, TRUE);
 923                 trace->stream_classes = NULL;
 924         }
 925
 926         g_free(trace);
 927 }
 928
 929 static inline
 930 struct fs_sink_ctf_trace *fs_sink_ctf_trace_create(const bt_trace *ir_trace)
 931 {
 932         struct fs_sink_ctf_trace *trace =
 933                 g_new0(struct fs_sink_ctf_trace, 1);
 934
 935         BT_ASSERT(trace);
 936
 937         bt_uuid_generate(trace->uuid);
 938
 939         trace->ir_trace = ir_trace;
 940         trace->ir_tc = bt_trace_borrow_class_const(ir_trace);
 941         trace->stream_classes = g_ptr_array_new_with_free_func(
 942                 (GDestroyNotify) fs_sink_ctf_stream_class_destroy);
 943         BT_ASSERT(trace->stream_classes);
 944
 945         return trace;
 946 }
 947
 948 #endif /* BABELTRACE_PLUGIN_CTF_FS_SINK_FS_SINK_CTF_META_H */