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