projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: decouple variant FC option names from selector FC mapping names
[babeltrace.git] / src / plugins / ctf / fs-sink / fs-sink-ctf-meta.h
CommitLineData
15fe47e0
PP		 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
3fadfbc0 18#include <babeltrace2/babeltrace.h>
578e048b
MJ		 19#include "common/common.h"
20#include "common/assert.h"
6162e6b7 21#include "common/uuid.h"
15fe47e0
PP		 22#include <glib.h>
23#include <stdint.h>
24#include <string.h>
25#include <stdbool.h>
26#include <ctype.h>
27
28enum 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
38struct 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
50struct fs_sink_ctf_field_class_bit_array {
51 struct fs_sink_ctf_field_class base;
52 unsigned int size;
53};
54
55struct fs_sink_ctf_field_class_int {
56 struct fs_sink_ctf_field_class_bit_array base;
57 bool is_signed;
58};
59
60struct fs_sink_ctf_field_class_float {
61 struct fs_sink_ctf_field_class_bit_array base;
62};
63
64struct fs_sink_ctf_field_class_string {
65 struct fs_sink_ctf_field_class base;
66};
67
68struct fs_sink_ctf_named_field_class {
69 GString *name;
70
71 /* Owned by this */
72 struct fs_sink_ctf_field_class *fc;
73};
74
75struct 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
82struct 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
91struct 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
96struct fs_sink_ctf_field_class_array {
97 struct fs_sink_ctf_field_class_array_base base;
98 uint64_t length;
99};
100
101struct 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
107struct fs_sink_ctf_stream_class;
108
109struct 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
335a2da5 123struct fs_sink_ctf_trace;
15fe47e0
PP		 124
125struct fs_sink_ctf_stream_class {
126 /* Weak */
335a2da5 127 struct fs_sink_ctf_trace *trace;
15fe47e0
PP		 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;
26fc5aed 136 bool has_packets;
ffb5c13c
PP		 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;
15fe47e0
PP		 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
335a2da5
PP		 159struct fs_sink_ctf_trace {
160 /* Weak */
161 const bt_trace *ir_trace;
162
15fe47e0
PP		 163 /* Weak */
164 const bt_trace_class *ir_tc;
165
6162e6b7 166 bt_uuid_t uuid;
15fe47e0
PP		 167
168 /* Array of `struct fs_sink_ctf_stream_class *` (owned by this) */
169 GPtrArray *stream_classes;
170};
171
172static inline
173void fs_sink_ctf_field_class_destroy(struct fs_sink_ctf_field_class *fc);
174
175static inline
176void _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
188static inline
189void _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
200static inline
201void _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
215static inline
216void _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
224static inline
225void _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
239static inline
240struct 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
252static inline
253struct 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
267static inline
268struct 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
281static inline
282struct 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
297static inline
298struct 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 =
45c51519
PP		 314 bt_field_class_get_type(fc->base.ir_fc) ==
315 BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR;
15fe47e0
PP		 316 return fc;
317}
318
319static inline
320struct 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
334static inline
335struct 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
353static inline
354struct fs_sink_ctf_named_field_class *
355fs_sink_ctf_field_class_struct_borrow_member_by_index(
356 struct fs_sink_ctf_field_class_struct *fc, uint64_t index);
357
358static inline
359struct fs_sink_ctf_named_field_class *
360fs_sink_ctf_field_class_variant_borrow_option_by_index(
361 struct fs_sink_ctf_field_class_variant *fc, uint64_t index);
362
363static inline
364void _fs_sink_ctf_field_class_fini(struct fs_sink_ctf_field_class *fc)
365{
366 BT_ASSERT(fc);
367}
368
369static inline
370void _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
378static inline
379void _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
387static inline
388void _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
396static inline
397void _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
421static inline
422void _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
431static inline
432void _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
440static inline
441void _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
455static inline
456void _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
485static inline
486void 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
519static inline
520struct fs_sink_ctf_named_field_class *
521fs_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
530static inline
531struct fs_sink_ctf_named_field_class *
532fs_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
552end:
553 return ret_named_fc;
554}
555
556static inline
557struct fs_sink_ctf_field_class *
558fs_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
576end:
577 return fc;
578}
579
580static inline
581struct fs_sink_ctf_field_class_int *
582fs_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
600end:
601 return int_fc;
602}
603
604static inline
605void 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
614static inline
615void 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
633static inline
634struct fs_sink_ctf_named_field_class *
635fs_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
644static inline
645struct fs_sink_ctf_named_field_class *
646fs_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
666end:
667 return ret_named_fc;
668}
669
670static inline
671void 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
688static inline
689struct 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
706static inline
707void 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
720static inline
721struct fs_sink_ctf_stream_class *fs_sink_ctf_stream_class_create(
335a2da5 722 struct fs_sink_ctf_trace *trace,
15fe47e0
PP		 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
335a2da5 728 BT_ASSERT(trace);
15fe47e0
PP		 729 BT_ASSERT(ir_sc);
730 BT_ASSERT(sc);
335a2da5 731 sc->trace = trace;
15fe47e0
PP		 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);
26fc5aed 743 sc->has_packets = bt_stream_class_supports_packets(ir_sc);
ffb5c13c 744 sc->packets_have_ts_begin =
9b24b6aa 745 bt_stream_class_packets_have_beginning_default_clock_snapshot(
ffb5c13c
PP		 746 ir_sc);
747 sc->packets_have_ts_end =
9b24b6aa 748 bt_stream_class_packets_have_end_default_clock_snapshot(ir_sc);
ffb5c13c
PP		 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
335a2da5 764 g_ptr_array_add(trace->stream_classes, sc);
15fe47e0
PP		 765 return sc;
766}
767
768static inline
769void 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
797static inline
798void 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
805static inline
335a2da5 806void fs_sink_ctf_trace_destroy(struct fs_sink_ctf_trace *trace)
15fe47e0 807{
335a2da5 808 if (!trace) {
15fe47e0
PP		 809 return;
810 }
811
335a2da5
PP		 812 if (trace->stream_classes) {
813 g_ptr_array_free(trace->stream_classes, TRUE);
814 trace->stream_classes = NULL;
15fe47e0
PP		 815 }
816
335a2da5 817 g_free(trace);
15fe47e0
PP		 818}
819
820static inline
335a2da5 821struct fs_sink_ctf_trace *fs_sink_ctf_trace_create(const bt_trace *ir_trace)
15fe47e0 822{
335a2da5
PP		 823 struct fs_sink_ctf_trace *trace =
824 g_new0(struct fs_sink_ctf_trace, 1);
15fe47e0 825
335a2da5 826 BT_ASSERT(trace);
15fe47e0 827
6162e6b7 828 bt_uuid_generate(trace->uuid);
15fe47e0 829
335a2da5
PP		 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(
15fe47e0 833 (GDestroyNotify) fs_sink_ctf_stream_class_destroy);
335a2da5 834 BT_ASSERT(trace->stream_classes);
15fe47e0 835
335a2da5 836 return trace;
15fe47e0
PP		 837}
838
15fe47e0 839#endif /* BABELTRACE_PLUGIN_CTF_FS_SINK_FS_SINK_CTF_META_H */
BabelTrace - Trace Format Babel Tower
This page took 0.063285 seconds and 4 git commands to generate.