lib: add aliases for Babeltrace structure types
[babeltrace.git] / plugins / ctf / common / metadata / ctf-meta.h
1 #ifndef _CTF_META_H
2 #define _CTF_META_H
3
4 /*
5 * Copyright 2018 - 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 <babeltrace/babeltrace.h>
19 #include <babeltrace/common-internal.h>
20 #include <babeltrace/assert-internal.h>
21 #include <glib.h>
22 #include <stdint.h>
23 #include <string.h>
24
25 enum ctf_field_class_type {
26 CTF_FIELD_CLASS_TYPE_INT,
27 CTF_FIELD_CLASS_TYPE_ENUM,
28 CTF_FIELD_CLASS_TYPE_FLOAT,
29 CTF_FIELD_CLASS_TYPE_STRING,
30 CTF_FIELD_CLASS_TYPE_STRUCT,
31 CTF_FIELD_CLASS_TYPE_ARRAY,
32 CTF_FIELD_CLASS_TYPE_SEQUENCE,
33 CTF_FIELD_CLASS_TYPE_VARIANT,
34 };
35
36 enum ctf_field_class_meaning {
37 CTF_FIELD_CLASS_MEANING_NONE,
38 CTF_FIELD_CLASS_MEANING_PACKET_BEGINNING_TIME,
39 CTF_FIELD_CLASS_MEANING_PACKET_END_TIME,
40 CTF_FIELD_CLASS_MEANING_EVENT_CLASS_ID,
41 CTF_FIELD_CLASS_MEANING_STREAM_CLASS_ID,
42 CTF_FIELD_CLASS_MEANING_DATA_STREAM_ID,
43 CTF_FIELD_CLASS_MEANING_MAGIC,
44 CTF_FIELD_CLASS_MEANING_PACKET_COUNTER_SNAPSHOT,
45 CTF_FIELD_CLASS_MEANING_DISC_EV_REC_COUNTER_SNAPSHOT,
46 CTF_FIELD_CLASS_MEANING_EXP_PACKET_TOTAL_SIZE,
47 CTF_FIELD_CLASS_MEANING_EXP_PACKET_CONTENT_SIZE,
48 CTF_FIELD_CLASS_MEANING_UUID,
49 };
50
51 enum ctf_byte_order {
52 CTF_BYTE_ORDER_DEFAULT,
53 CTF_BYTE_ORDER_LITTLE,
54 CTF_BYTE_ORDER_BIG,
55 };
56
57 enum ctf_encoding {
58 CTF_ENCODING_NONE,
59 CTF_ENCODING_UTF8,
60 };
61
62 struct ctf_field_class {
63 enum ctf_field_class_type type;
64 unsigned int alignment;
65 bool is_compound;
66 bool in_ir;
67
68 /* Weak, set during translation. NULL if `in_ir` is false below. */
69 bt_field_class *ir_fc;
70 };
71
72 struct ctf_field_class_bit_array {
73 struct ctf_field_class base;
74 enum ctf_byte_order byte_order;
75 unsigned int size;
76 };
77
78 struct ctf_field_class_int {
79 struct ctf_field_class_bit_array base;
80 enum ctf_field_class_meaning meaning;
81 bool is_signed;
82 enum bt_field_class_integer_preferred_display_base disp_base;
83 enum ctf_encoding encoding;
84 int64_t storing_index;
85
86 /* Owned by this */
87 bt_clock_class *mapped_clock_class;
88 };
89
90 struct ctf_range {
91 union {
92 uint64_t u;
93 int64_t i;
94 } lower;
95
96 union {
97 uint64_t u;
98 int64_t i;
99 } upper;
100 };
101
102 struct ctf_field_class_enum_mapping {
103 GString *label;
104 struct ctf_range range;
105 };
106
107 struct ctf_field_class_enum {
108 struct ctf_field_class_int base;
109
110 /* Array of `struct ctf_field_class_enum_mapping` */
111 GArray *mappings;
112 };
113
114 struct ctf_field_class_float {
115 struct ctf_field_class_bit_array base;
116 };
117
118 struct ctf_field_class_string {
119 struct ctf_field_class base;
120 enum ctf_encoding encoding;
121 };
122
123 struct ctf_named_field_class {
124 GString *name;
125
126 /* Owned by this */
127 struct ctf_field_class *fc;
128 };
129
130 struct ctf_field_class_struct {
131 struct ctf_field_class base;
132
133 /* Array of `struct ctf_named_field_class` */
134 GArray *members;
135 };
136
137 struct ctf_field_path {
138 enum bt_scope root;
139
140 /* Array of `int64_t` */
141 GArray *path;
142 };
143
144 struct ctf_field_class_variant_range {
145 struct ctf_range range;
146 uint64_t option_index;
147 };
148
149 struct ctf_field_class_variant {
150 struct ctf_field_class base;
151 GString *tag_ref;
152 struct ctf_field_path tag_path;
153 uint64_t stored_tag_index;
154
155 /* Array of `struct ctf_named_field_class` */
156 GArray *options;
157
158 /* Array of `struct ctf_field_class_variant_range` */
159 GArray *ranges;
160
161 /* Weak */
162 struct ctf_field_class_enum *tag_fc;
163 };
164
165 struct ctf_field_class_array_base {
166 struct ctf_field_class base;
167 struct ctf_field_class *elem_fc;
168 bool is_text;
169 };
170
171 struct ctf_field_class_array {
172 struct ctf_field_class_array_base base;
173 enum ctf_field_class_meaning meaning;
174 uint64_t length;
175 };
176
177 struct ctf_field_class_sequence {
178 struct ctf_field_class_array_base base;
179 GString *length_ref;
180 struct ctf_field_path length_path;
181 uint64_t stored_length_index;
182
183 /* Weak */
184 struct ctf_field_class_int *length_fc;
185 };
186
187 struct ctf_event_class {
188 GString *name;
189 uint64_t id;
190 GString *emf_uri;
191 enum bt_event_class_log_level log_level;
192 bool is_translated;
193
194 /* Owned by this */
195 struct ctf_field_class *spec_context_fc;
196
197 /* Owned by this */
198 struct ctf_field_class *payload_fc;
199
200 /* Weak, set during translation */
201 bt_event_class *ir_ec;
202 };
203
204 struct ctf_stream_class {
205 uint64_t id;
206 bool is_translated;
207
208 /* Owned by this */
209 struct ctf_field_class *packet_context_fc;
210
211 /* Owned by this */
212 struct ctf_field_class *event_header_fc;
213
214 /* Owned by this */
215 struct ctf_field_class *event_common_context_fc;
216
217 /* Array of `struct ctf_event_class *`, owned by this */
218 GPtrArray *event_classes;
219
220 /*
221 * Hash table mapping event class IDs to `struct ctf_event_class *`,
222 * weak.
223 */
224 GHashTable *event_classes_by_id;
225
226 /* Owned by this */
227 bt_clock_class *default_clock_class;
228
229 /* Weak, set during translation */
230 bt_stream_class *ir_sc;
231 };
232
233 enum ctf_trace_class_env_entry_type {
234 CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT,
235 CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR,
236 };
237
238 struct ctf_trace_class_env_entry {
239 enum ctf_trace_class_env_entry_type type;
240 GString *name;
241
242 struct {
243 int64_t i;
244 GString *str;
245 } value;
246 };
247
248 struct ctf_trace_class {
249 unsigned int major;
250 unsigned int minor;
251 uint8_t uuid[16];
252 bool is_uuid_set;
253 enum ctf_byte_order default_byte_order;
254
255 /* Owned by this */
256 struct ctf_field_class *packet_header_fc;
257
258 uint64_t stored_value_count;
259
260 /* Array of `bt_clock_class *` (owned by this) */
261 GPtrArray *clock_classes;
262
263 /* Array of `struct ctf_stream_class *` */
264 GPtrArray *stream_classes;
265
266 /* Array of `struct ctf_trace_class_env_entry` */
267 GArray *env_entries;
268
269 bool is_translated;
270
271 /* Weak, set during translation */
272 bt_trace_class *ir_tc;
273 };
274
275 static inline
276 void ctf_field_class_destroy(struct ctf_field_class *fc);
277
278 static inline
279 void _ctf_field_class_init(struct ctf_field_class *fc,
280 enum ctf_field_class_type type, unsigned int alignment)
281 {
282 BT_ASSERT(fc);
283 fc->type = type;
284 fc->alignment = alignment;
285 fc->in_ir = false;
286 }
287
288 static inline
289 void _ctf_field_class_bit_array_init(struct ctf_field_class_bit_array *fc,
290 enum ctf_field_class_type type)
291 {
292 _ctf_field_class_init((void *) fc, type, 1);
293 }
294
295 static inline
296 void _ctf_field_class_int_init(struct ctf_field_class_int *fc,
297 enum ctf_field_class_type type)
298 {
299 _ctf_field_class_bit_array_init((void *) fc, type);
300 fc->meaning = CTF_FIELD_CLASS_MEANING_NONE;
301 fc->storing_index = -1;
302 }
303
304 static inline
305 void ctf_field_path_init(struct ctf_field_path *field_path)
306 {
307 BT_ASSERT(field_path);
308 field_path->path = g_array_new(FALSE, TRUE, sizeof(int64_t));
309 BT_ASSERT(field_path->path);
310 }
311
312 static inline
313 void ctf_field_path_fini(struct ctf_field_path *field_path)
314 {
315 BT_ASSERT(field_path);
316
317 if (field_path->path) {
318 g_array_free(field_path->path, TRUE);
319 }
320 }
321
322 static inline
323 void _ctf_named_field_class_init(struct ctf_named_field_class *named_fc)
324 {
325 BT_ASSERT(named_fc);
326 named_fc->name = g_string_new(NULL);
327 BT_ASSERT(named_fc->name);
328 }
329
330 static inline
331 void _ctf_named_field_class_fini(struct ctf_named_field_class *named_fc)
332 {
333 BT_ASSERT(named_fc);
334
335 if (named_fc->name) {
336 g_string_free(named_fc->name, TRUE);
337 }
338
339 ctf_field_class_destroy(named_fc->fc);
340 }
341
342 static inline
343 void _ctf_field_class_enum_mapping_init(
344 struct ctf_field_class_enum_mapping *mapping)
345 {
346 BT_ASSERT(mapping);
347 mapping->label = g_string_new(NULL);
348 BT_ASSERT(mapping->label);
349 }
350
351 static inline
352 void _ctf_field_class_enum_mapping_fini(
353 struct ctf_field_class_enum_mapping *mapping)
354 {
355 BT_ASSERT(mapping);
356
357 if (mapping->label) {
358 g_string_free(mapping->label, TRUE);
359 }
360 }
361
362 static inline
363 struct ctf_field_class_int *ctf_field_class_int_create(void)
364 {
365 struct ctf_field_class_int *fc = g_new0(struct ctf_field_class_int, 1);
366
367 BT_ASSERT(fc);
368 _ctf_field_class_int_init(fc, CTF_FIELD_CLASS_TYPE_INT);
369 return fc;
370 }
371
372 static inline
373 struct ctf_field_class_float *ctf_field_class_float_create(void)
374 {
375 struct ctf_field_class_float *fc =
376 g_new0(struct ctf_field_class_float, 1);
377
378 BT_ASSERT(fc);
379 _ctf_field_class_bit_array_init((void *) fc, CTF_FIELD_CLASS_TYPE_FLOAT);
380 return fc;
381 }
382
383 static inline
384 struct ctf_field_class_string *ctf_field_class_string_create(void)
385 {
386 struct ctf_field_class_string *fc =
387 g_new0(struct ctf_field_class_string, 1);
388
389 BT_ASSERT(fc);
390 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_STRING, 8);
391 return fc;
392 }
393
394 static inline
395 struct ctf_field_class_enum *ctf_field_class_enum_create(void)
396 {
397 struct ctf_field_class_enum *fc = g_new0(struct ctf_field_class_enum, 1);
398
399 BT_ASSERT(fc);
400 _ctf_field_class_int_init((void *) fc, CTF_FIELD_CLASS_TYPE_ENUM);
401 fc->mappings = g_array_new(FALSE, TRUE,
402 sizeof(struct ctf_field_class_enum_mapping));
403 BT_ASSERT(fc->mappings);
404 return fc;
405 }
406
407 static inline
408 struct ctf_field_class_struct *ctf_field_class_struct_create(void)
409 {
410 struct ctf_field_class_struct *fc =
411 g_new0(struct ctf_field_class_struct, 1);
412
413 BT_ASSERT(fc);
414 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_STRUCT, 1);
415 fc->members = g_array_new(FALSE, TRUE,
416 sizeof(struct ctf_named_field_class));
417 BT_ASSERT(fc->members);
418 fc->base.is_compound = true;
419 return fc;
420 }
421
422 static inline
423 struct ctf_field_class_variant *ctf_field_class_variant_create(void)
424 {
425 struct ctf_field_class_variant *fc =
426 g_new0(struct ctf_field_class_variant, 1);
427
428 BT_ASSERT(fc);
429 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_VARIANT, 1);
430 fc->options = g_array_new(FALSE, TRUE,
431 sizeof(struct ctf_named_field_class));
432 BT_ASSERT(fc->options);
433 fc->ranges = g_array_new(FALSE, TRUE,
434 sizeof(struct ctf_field_class_variant_range));
435 BT_ASSERT(fc->ranges);
436 fc->tag_ref = g_string_new(NULL);
437 BT_ASSERT(fc->tag_ref);
438 ctf_field_path_init(&fc->tag_path);
439 fc->base.is_compound = true;
440 return fc;
441 }
442
443 static inline
444 struct ctf_field_class_array *ctf_field_class_array_create(void)
445 {
446 struct ctf_field_class_array *fc =
447 g_new0(struct ctf_field_class_array, 1);
448
449 BT_ASSERT(fc);
450 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_ARRAY, 1);
451 fc->base.base.is_compound = true;
452 return fc;
453 }
454
455 static inline
456 struct ctf_field_class_sequence *ctf_field_class_sequence_create(void)
457 {
458 struct ctf_field_class_sequence *fc =
459 g_new0(struct ctf_field_class_sequence, 1);
460
461 BT_ASSERT(fc);
462 _ctf_field_class_init((void *) fc, CTF_FIELD_CLASS_TYPE_SEQUENCE, 1);
463 fc->length_ref = g_string_new(NULL);
464 BT_ASSERT(fc->length_ref);
465 ctf_field_path_init(&fc->length_path);
466 fc->base.base.is_compound = true;
467 return fc;
468 }
469
470 static inline
471 void _ctf_field_class_int_destroy(struct ctf_field_class_int *fc)
472 {
473 BT_ASSERT(fc);
474 bt_clock_class_put_ref(fc->mapped_clock_class);
475 g_free(fc);
476 }
477
478 static inline
479 void _ctf_field_class_enum_destroy(struct ctf_field_class_enum *fc)
480 {
481 BT_ASSERT(fc);
482 bt_clock_class_put_ref(fc->base.mapped_clock_class);
483
484 if (fc->mappings) {
485 uint64_t i;
486
487 for (i = 0; i < fc->mappings->len; i++) {
488 struct ctf_field_class_enum_mapping *mapping =
489 &g_array_index(fc->mappings,
490 struct ctf_field_class_enum_mapping, i);
491
492 _ctf_field_class_enum_mapping_fini(mapping);
493 }
494
495 g_array_free(fc->mappings, TRUE);
496 }
497
498 g_free(fc);
499 }
500
501 static inline
502 void _ctf_field_class_float_destroy(struct ctf_field_class_float *fc)
503 {
504 BT_ASSERT(fc);
505 g_free(fc);
506 }
507
508 static inline
509 void _ctf_field_class_string_destroy(struct ctf_field_class_string *fc)
510 {
511 BT_ASSERT(fc);
512 g_free(fc);
513 }
514
515 static inline
516 void _ctf_field_class_struct_destroy(struct ctf_field_class_struct *fc)
517 {
518 BT_ASSERT(fc);
519
520 if (fc->members) {
521 uint64_t i;
522
523 for (i = 0; i < fc->members->len; i++) {
524 struct ctf_named_field_class *named_fc =
525 &g_array_index(fc->members,
526 struct ctf_named_field_class, i);
527
528 _ctf_named_field_class_fini(named_fc);
529 }
530
531 g_array_free(fc->members, TRUE);
532 }
533
534 g_free(fc);
535 }
536
537 static inline
538 void _ctf_field_class_array_base_fini(struct ctf_field_class_array_base *fc)
539 {
540 BT_ASSERT(fc);
541 ctf_field_class_destroy(fc->elem_fc);
542 }
543
544 static inline
545 void _ctf_field_class_array_destroy(struct ctf_field_class_array *fc)
546 {
547 BT_ASSERT(fc);
548 _ctf_field_class_array_base_fini((void *) fc);
549 g_free(fc);
550 }
551
552 static inline
553 void _ctf_field_class_sequence_destroy(struct ctf_field_class_sequence *fc)
554 {
555 BT_ASSERT(fc);
556 _ctf_field_class_array_base_fini((void *) fc);
557
558 if (fc->length_ref) {
559 g_string_free(fc->length_ref, TRUE);
560 }
561
562 ctf_field_path_fini(&fc->length_path);
563 g_free(fc);
564 }
565
566 static inline
567 void _ctf_field_class_variant_destroy(struct ctf_field_class_variant *fc)
568 {
569 BT_ASSERT(fc);
570
571 if (fc->options) {
572 uint64_t i;
573
574 for (i = 0; i < fc->options->len; i++) {
575 struct ctf_named_field_class *named_fc =
576 &g_array_index(fc->options,
577 struct ctf_named_field_class, i);
578
579 _ctf_named_field_class_fini(named_fc);
580 }
581
582 g_array_free(fc->options, TRUE);
583 }
584
585 if (fc->ranges) {
586 g_array_free(fc->ranges, TRUE);
587 }
588
589 if (fc->tag_ref) {
590 g_string_free(fc->tag_ref, TRUE);
591 }
592
593 ctf_field_path_fini(&fc->tag_path);
594 g_free(fc);
595 }
596
597 static inline
598 void ctf_field_class_destroy(struct ctf_field_class *fc)
599 {
600 if (!fc) {
601 return;
602 }
603
604 switch (fc->type) {
605 case CTF_FIELD_CLASS_TYPE_INT:
606 _ctf_field_class_int_destroy((void *) fc);
607 break;
608 case CTF_FIELD_CLASS_TYPE_ENUM:
609 _ctf_field_class_enum_destroy((void *) fc);
610 break;
611 case CTF_FIELD_CLASS_TYPE_FLOAT:
612 _ctf_field_class_float_destroy((void *) fc);
613 break;
614 case CTF_FIELD_CLASS_TYPE_STRING:
615 _ctf_field_class_string_destroy((void *) fc);
616 break;
617 case CTF_FIELD_CLASS_TYPE_STRUCT:
618 _ctf_field_class_struct_destroy((void *) fc);
619 break;
620 case CTF_FIELD_CLASS_TYPE_ARRAY:
621 _ctf_field_class_array_destroy((void *) fc);
622 break;
623 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
624 _ctf_field_class_sequence_destroy((void *) fc);
625 break;
626 case CTF_FIELD_CLASS_TYPE_VARIANT:
627 _ctf_field_class_variant_destroy((void *) fc);
628 break;
629 default:
630 abort();
631 }
632 }
633
634 static inline
635 void ctf_field_class_enum_append_mapping(struct ctf_field_class_enum *fc,
636 const char *label, uint64_t u_lower, uint64_t u_upper)
637 {
638 struct ctf_field_class_enum_mapping *mapping;
639
640 BT_ASSERT(fc);
641 BT_ASSERT(label);
642 g_array_set_size(fc->mappings, fc->mappings->len + 1);
643
644 mapping = &g_array_index(fc->mappings,
645 struct ctf_field_class_enum_mapping, fc->mappings->len - 1);
646 _ctf_field_class_enum_mapping_init(mapping);
647 g_string_assign(mapping->label, label);
648 mapping->range.lower.u = u_lower;
649 mapping->range.upper.u = u_upper;
650 }
651
652 static inline
653 struct ctf_field_class_enum_mapping *ctf_field_class_enum_borrow_mapping_by_index(
654 struct ctf_field_class_enum *fc, uint64_t index)
655 {
656 BT_ASSERT(fc);
657 BT_ASSERT(index < fc->mappings->len);
658 return &g_array_index(fc->mappings, struct ctf_field_class_enum_mapping,
659 index);
660 }
661
662 static inline
663 struct ctf_named_field_class *ctf_field_class_struct_borrow_member_by_index(
664 struct ctf_field_class_struct *fc, uint64_t index)
665 {
666 BT_ASSERT(fc);
667 BT_ASSERT(index < fc->members->len);
668 return &g_array_index(fc->members, struct ctf_named_field_class,
669 index);
670 }
671
672 static inline
673 struct ctf_named_field_class *ctf_field_class_struct_borrow_member_by_name(
674 struct ctf_field_class_struct *fc, const char *name)
675 {
676 uint64_t i;
677 struct ctf_named_field_class *ret_named_fc = NULL;
678
679 BT_ASSERT(fc);
680 BT_ASSERT(name);
681
682 for (i = 0; i < fc->members->len; i++) {
683 struct ctf_named_field_class *named_fc =
684 ctf_field_class_struct_borrow_member_by_index(fc, i);
685
686 if (strcmp(name, named_fc->name->str) == 0) {
687 ret_named_fc = named_fc;
688 goto end;
689 }
690 }
691
692 end:
693 return ret_named_fc;
694 }
695
696 static inline
697 struct ctf_field_class *ctf_field_class_struct_borrow_member_field_class_by_name(
698 struct ctf_field_class_struct *struct_fc, const char *name)
699 {
700 struct ctf_named_field_class *named_fc = NULL;
701 struct ctf_field_class *fc = NULL;
702
703 if (!struct_fc) {
704 goto end;
705 }
706
707 named_fc = ctf_field_class_struct_borrow_member_by_name(struct_fc, name);
708 if (!named_fc) {
709 goto end;
710 }
711
712 fc = named_fc->fc;
713
714 end:
715 return fc;
716 }
717
718 static inline
719 struct ctf_field_class_int *
720 ctf_field_class_struct_borrow_member_int_field_class_by_name(
721 struct ctf_field_class_struct *struct_fc, const char *name)
722 {
723 struct ctf_field_class_int *int_fc = NULL;
724
725 int_fc = (void *)
726 ctf_field_class_struct_borrow_member_field_class_by_name(
727 struct_fc, name);
728 if (!int_fc) {
729 goto end;
730 }
731
732 if (int_fc->base.base.type != CTF_FIELD_CLASS_TYPE_INT &&
733 int_fc->base.base.type != CTF_FIELD_CLASS_TYPE_ENUM) {
734 int_fc = NULL;
735 goto end;
736 }
737
738 end:
739 return int_fc;
740 }
741
742
743 static inline
744 void ctf_field_class_struct_append_member(struct ctf_field_class_struct *fc,
745 const char *name, struct ctf_field_class *member_fc)
746 {
747 struct ctf_named_field_class *named_fc;
748
749 BT_ASSERT(fc);
750 BT_ASSERT(name);
751 g_array_set_size(fc->members, fc->members->len + 1);
752
753 named_fc = &g_array_index(fc->members, struct ctf_named_field_class,
754 fc->members->len - 1);
755 _ctf_named_field_class_init(named_fc);
756 g_string_assign(named_fc->name, name);
757 named_fc->fc = member_fc;
758
759 if (member_fc->alignment > fc->base.alignment) {
760 fc->base.alignment = member_fc->alignment;
761 }
762 }
763
764 static inline
765 struct ctf_named_field_class *ctf_field_class_variant_borrow_option_by_index(
766 struct ctf_field_class_variant *fc, uint64_t index)
767 {
768 BT_ASSERT(fc);
769 BT_ASSERT(index < fc->options->len);
770 return &g_array_index(fc->options, struct ctf_named_field_class,
771 index);
772 }
773
774 static inline
775 struct ctf_named_field_class *ctf_field_class_variant_borrow_option_by_name(
776 struct ctf_field_class_variant *fc, const char *name)
777 {
778 uint64_t i;
779 struct ctf_named_field_class *ret_named_fc = NULL;
780
781 BT_ASSERT(fc);
782 BT_ASSERT(name);
783
784 for (i = 0; i < fc->options->len; i++) {
785 struct ctf_named_field_class *named_fc =
786 ctf_field_class_variant_borrow_option_by_index(fc, i);
787
788 if (strcmp(name, named_fc->name->str) == 0) {
789 ret_named_fc = named_fc;
790 goto end;
791 }
792 }
793
794 end:
795 return ret_named_fc;
796 }
797
798 static inline
799 struct ctf_field_class_variant_range *
800 ctf_field_class_variant_borrow_range_by_index(
801 struct ctf_field_class_variant *fc, uint64_t index)
802 {
803 BT_ASSERT(fc);
804 BT_ASSERT(index < fc->ranges->len);
805 return &g_array_index(fc->ranges, struct ctf_field_class_variant_range,
806 index);
807 }
808
809 static inline
810 void ctf_field_class_variant_append_option(struct ctf_field_class_variant *fc,
811 const char *name, struct ctf_field_class *option_fc)
812 {
813 struct ctf_named_field_class *named_fc;
814
815 BT_ASSERT(fc);
816 BT_ASSERT(name);
817 g_array_set_size(fc->options, fc->options->len + 1);
818
819 named_fc = &g_array_index(fc->options, struct ctf_named_field_class,
820 fc->options->len - 1);
821 _ctf_named_field_class_init(named_fc);
822 g_string_assign(named_fc->name, name);
823 named_fc->fc = option_fc;
824 }
825
826 static inline
827 void ctf_field_class_variant_set_tag_field_class(
828 struct ctf_field_class_variant *fc,
829 struct ctf_field_class_enum *tag_fc)
830 {
831 uint64_t option_i;
832
833 BT_ASSERT(fc);
834 BT_ASSERT(tag_fc);
835 fc->tag_fc = tag_fc;
836
837 for (option_i = 0; option_i < fc->options->len; option_i++) {
838 uint64_t mapping_i;
839 struct ctf_named_field_class *named_fc =
840 ctf_field_class_variant_borrow_option_by_index(
841 fc, option_i);
842
843 for (mapping_i = 0; mapping_i < tag_fc->mappings->len;
844 mapping_i++) {
845 struct ctf_field_class_enum_mapping *mapping =
846 ctf_field_class_enum_borrow_mapping_by_index(
847 tag_fc, mapping_i);
848
849 if (strcmp(named_fc->name->str,
850 mapping->label->str) == 0) {
851 struct ctf_field_class_variant_range range;
852
853 range.range = mapping->range;
854 range.option_index = option_i;
855 g_array_append_val(fc->ranges, range);
856 }
857 }
858 }
859 }
860
861 static inline
862 struct ctf_field_class *ctf_field_class_compound_borrow_field_class_by_index(
863 struct ctf_field_class *comp_fc, uint64_t index)
864 {
865 struct ctf_field_class *fc = NULL;
866
867 switch (comp_fc->type) {
868 case CTF_FIELD_CLASS_TYPE_STRUCT:
869 {
870 struct ctf_named_field_class *named_fc =
871 ctf_field_class_struct_borrow_member_by_index(
872 (void *) comp_fc, index);
873
874 BT_ASSERT(named_fc);
875 fc = named_fc->fc;
876 break;
877 }
878 case CTF_FIELD_CLASS_TYPE_VARIANT:
879 {
880 struct ctf_named_field_class *named_fc =
881 ctf_field_class_variant_borrow_option_by_index(
882 (void *) comp_fc, index);
883
884 BT_ASSERT(named_fc);
885 fc = named_fc->fc;
886 break;
887 }
888 case CTF_FIELD_CLASS_TYPE_ARRAY:
889 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
890 {
891 struct ctf_field_class_array_base *array_fc = (void *) comp_fc;
892
893 fc = array_fc->elem_fc;
894 break;
895 }
896 default:
897 break;
898 }
899
900 return fc;
901 }
902
903 static inline
904 uint64_t ctf_field_class_compound_get_field_class_count(struct ctf_field_class *fc)
905 {
906 uint64_t field_count;
907
908 switch (fc->type) {
909 case CTF_FIELD_CLASS_TYPE_STRUCT:
910 {
911 struct ctf_field_class_struct *struct_fc = (void *) fc;
912
913 field_count = struct_fc->members->len;
914 break;
915 }
916 case CTF_FIELD_CLASS_TYPE_VARIANT:
917 {
918 struct ctf_field_class_variant *var_fc = (void *) fc;
919
920 field_count = var_fc->options->len;
921 break;
922 }
923 case CTF_FIELD_CLASS_TYPE_ARRAY:
924 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
925 /*
926 * Array and sequence types always contain a single
927 * member (the element type).
928 */
929 field_count = 1;
930 break;
931 default:
932 abort();
933 }
934
935 return field_count;
936 }
937
938 static inline
939 int64_t ctf_field_class_compound_get_field_class_index_from_name(
940 struct ctf_field_class *fc, const char *name)
941 {
942 int64_t ret_index = -1;
943 uint64_t i;
944
945 switch (fc->type) {
946 case CTF_FIELD_CLASS_TYPE_STRUCT:
947 {
948 struct ctf_field_class_struct *struct_fc = (void *) fc;
949
950 for (i = 0; i < struct_fc->members->len; i++) {
951 struct ctf_named_field_class *named_fc =
952 ctf_field_class_struct_borrow_member_by_index(
953 struct_fc, i);
954
955 if (strcmp(name, named_fc->name->str) == 0) {
956 ret_index = (int64_t) i;
957 goto end;
958 }
959 }
960
961 break;
962 }
963 case CTF_FIELD_CLASS_TYPE_VARIANT:
964 {
965 struct ctf_field_class_variant *var_fc = (void *) fc;
966
967 for (i = 0; i < var_fc->options->len; i++) {
968 struct ctf_named_field_class *named_fc =
969 ctf_field_class_variant_borrow_option_by_index(
970 var_fc, i);
971
972 if (strcmp(name, named_fc->name->str) == 0) {
973 ret_index = (int64_t) i;
974 goto end;
975 }
976 }
977
978 break;
979 }
980 default:
981 break;
982 }
983
984 end:
985 return ret_index;
986 }
987
988 static inline
989 void ctf_field_path_append_index(struct ctf_field_path *fp, int64_t index)
990 {
991 BT_ASSERT(fp);
992 g_array_append_val(fp->path, index);
993 }
994
995 static inline
996 int64_t ctf_field_path_borrow_index_by_index(struct ctf_field_path *fp,
997 uint64_t index)
998 {
999 BT_ASSERT(fp);
1000 BT_ASSERT(index < fp->path->len);
1001 return g_array_index(fp->path, int64_t, index);
1002 }
1003
1004 static inline
1005 void ctf_field_path_clear(struct ctf_field_path *fp)
1006 {
1007 BT_ASSERT(fp);
1008 g_array_set_size(fp->path, 0);
1009 }
1010
1011 static inline
1012 GString *ctf_field_path_string(struct ctf_field_path *path)
1013 {
1014 GString *str = g_string_new(NULL);
1015 uint64_t i;
1016
1017 BT_ASSERT(path);
1018
1019 if (!str) {
1020 goto end;
1021 }
1022
1023 g_string_append_printf(str, "[%s", bt_common_scope_string(
1024 path->root));
1025
1026 for (i = 0; i < path->path->len; i++) {
1027 g_string_append_printf(str, ", %" PRId64,
1028 ctf_field_path_borrow_index_by_index(path, i));
1029 }
1030
1031 g_string_append(str, "]");
1032
1033 end:
1034 return str;
1035 }
1036
1037 static inline
1038 struct ctf_field_class *ctf_field_path_borrow_field_class(
1039 struct ctf_field_path *field_path,
1040 struct ctf_trace_class *tc,
1041 struct ctf_stream_class *sc,
1042 struct ctf_event_class *ec)
1043 {
1044 uint64_t i;
1045 struct ctf_field_class *fc;
1046
1047 switch (field_path->root) {
1048 case BT_SCOPE_PACKET_HEADER:
1049 fc = tc->packet_header_fc;
1050 break;
1051 case BT_SCOPE_PACKET_CONTEXT:
1052 fc = sc->packet_context_fc;
1053 break;
1054 case BT_SCOPE_EVENT_HEADER:
1055 fc = sc->event_header_fc;
1056 break;
1057 case BT_SCOPE_EVENT_COMMON_CONTEXT:
1058 fc = sc->event_common_context_fc;
1059 break;
1060 case BT_SCOPE_EVENT_SPECIFIC_CONTEXT:
1061 fc = ec->spec_context_fc;
1062 break;
1063 case BT_SCOPE_EVENT_PAYLOAD:
1064 fc = ec->payload_fc;
1065 break;
1066 default:
1067 abort();
1068 }
1069
1070 BT_ASSERT(fc);
1071
1072 for (i = 0; i < field_path->path->len; i++) {
1073 int64_t child_index =
1074 ctf_field_path_borrow_index_by_index(field_path, i);
1075 struct ctf_field_class *child_fc =
1076 ctf_field_class_compound_borrow_field_class_by_index(
1077 fc, child_index);
1078 BT_ASSERT(child_fc);
1079 fc = child_fc;
1080 }
1081
1082 BT_ASSERT(fc);
1083 return fc;
1084 }
1085
1086 static inline
1087 struct ctf_field_class *ctf_field_class_copy(struct ctf_field_class *fc);
1088
1089 static inline
1090 void ctf_field_class_bit_array_copy_content(
1091 struct ctf_field_class_bit_array *dst_fc,
1092 struct ctf_field_class_bit_array *src_fc)
1093 {
1094 BT_ASSERT(dst_fc);
1095 BT_ASSERT(src_fc);
1096 dst_fc->byte_order = src_fc->byte_order;
1097 dst_fc->size = src_fc->size;
1098 }
1099
1100 static inline
1101 void ctf_field_class_int_copy_content(
1102 struct ctf_field_class_int *dst_fc,
1103 struct ctf_field_class_int *src_fc)
1104 {
1105 ctf_field_class_bit_array_copy_content((void *) dst_fc, (void *) src_fc);
1106 dst_fc->meaning = src_fc->meaning;
1107 dst_fc->is_signed = src_fc->is_signed;
1108 dst_fc->disp_base = src_fc->disp_base;
1109 dst_fc->encoding = src_fc->encoding;
1110 dst_fc->mapped_clock_class = src_fc->mapped_clock_class;
1111 bt_clock_class_get_ref(dst_fc->mapped_clock_class);
1112 dst_fc->storing_index = src_fc->storing_index;
1113 }
1114
1115 static inline
1116 struct ctf_field_class_int *_ctf_field_class_int_copy(
1117 struct ctf_field_class_int *fc)
1118 {
1119 struct ctf_field_class_int *copy_fc = ctf_field_class_int_create();
1120
1121 BT_ASSERT(copy_fc);
1122 ctf_field_class_int_copy_content(copy_fc, fc);
1123 return copy_fc;
1124 }
1125
1126 static inline
1127 struct ctf_field_class_enum *_ctf_field_class_enum_copy(
1128 struct ctf_field_class_enum *fc)
1129 {
1130 struct ctf_field_class_enum *copy_fc = ctf_field_class_enum_create();
1131 uint64_t i;
1132
1133 BT_ASSERT(copy_fc);
1134 ctf_field_class_int_copy_content((void *) copy_fc, (void *) fc);
1135
1136 for (i = 0; i < fc->mappings->len; i++) {
1137 struct ctf_field_class_enum_mapping *mapping =
1138 &g_array_index(fc->mappings,
1139 struct ctf_field_class_enum_mapping, i);
1140
1141 ctf_field_class_enum_append_mapping(copy_fc, mapping->label->str,
1142 mapping->range.lower.u, mapping->range.upper.u);
1143 }
1144
1145 return copy_fc;
1146 }
1147
1148 static inline
1149 struct ctf_field_class_float *_ctf_field_class_float_copy(
1150 struct ctf_field_class_float *fc)
1151 {
1152 struct ctf_field_class_float *copy_fc = ctf_field_class_float_create();
1153
1154 BT_ASSERT(copy_fc);
1155 ctf_field_class_bit_array_copy_content((void *) copy_fc, (void *) fc);
1156 return copy_fc;
1157 }
1158
1159 static inline
1160 struct ctf_field_class_string *_ctf_field_class_string_copy(
1161 struct ctf_field_class_string *fc)
1162 {
1163 struct ctf_field_class_string *copy_fc = ctf_field_class_string_create();
1164
1165 BT_ASSERT(copy_fc);
1166 return copy_fc;
1167 }
1168
1169 static inline
1170 struct ctf_field_class_struct *_ctf_field_class_struct_copy(
1171 struct ctf_field_class_struct *fc)
1172 {
1173 struct ctf_field_class_struct *copy_fc = ctf_field_class_struct_create();
1174 uint64_t i;
1175
1176 BT_ASSERT(copy_fc);
1177
1178 for (i = 0; i < fc->members->len; i++) {
1179 struct ctf_named_field_class *named_fc =
1180 &g_array_index(fc->members,
1181 struct ctf_named_field_class, i);
1182
1183 ctf_field_class_struct_append_member(copy_fc,
1184 named_fc->name->str,
1185 ctf_field_class_copy(named_fc->fc));
1186 }
1187
1188 return copy_fc;
1189 }
1190
1191 static inline
1192 void ctf_field_path_copy_content(struct ctf_field_path *dst_fp,
1193 struct ctf_field_path *src_fp)
1194 {
1195 uint64_t i;
1196
1197 BT_ASSERT(dst_fp);
1198 BT_ASSERT(src_fp);
1199 dst_fp->root = src_fp->root;
1200 ctf_field_path_clear(dst_fp);
1201
1202 for (i = 0; i < src_fp->path->len; i++) {
1203 int64_t index = ctf_field_path_borrow_index_by_index(
1204 src_fp, i);
1205
1206 ctf_field_path_append_index(dst_fp, index);
1207 }
1208 }
1209
1210 static inline
1211 struct ctf_field_class_variant *_ctf_field_class_variant_copy(
1212 struct ctf_field_class_variant *fc)
1213 {
1214 struct ctf_field_class_variant *copy_fc =
1215 ctf_field_class_variant_create();
1216 uint64_t i;
1217
1218 BT_ASSERT(copy_fc);
1219
1220 for (i = 0; i < fc->options->len; i++) {
1221 struct ctf_named_field_class *named_fc =
1222 &g_array_index(fc->options,
1223 struct ctf_named_field_class, i);
1224
1225 ctf_field_class_variant_append_option(copy_fc,
1226 named_fc->name->str,
1227 ctf_field_class_copy(named_fc->fc));
1228 }
1229
1230 for (i = 0; i < fc->ranges->len; i++) {
1231 struct ctf_field_class_variant_range *range =
1232 &g_array_index(fc->ranges,
1233 struct ctf_field_class_variant_range, i);
1234
1235 g_array_append_val(copy_fc->ranges, *range);
1236 }
1237
1238 ctf_field_path_copy_content(&copy_fc->tag_path, &fc->tag_path);
1239 g_string_assign(copy_fc->tag_ref, fc->tag_ref->str);
1240 copy_fc->stored_tag_index = fc->stored_tag_index;
1241 return copy_fc;
1242 }
1243
1244 static inline
1245 void ctf_field_class_array_base_copy_content(
1246 struct ctf_field_class_array_base *dst_fc,
1247 struct ctf_field_class_array_base *src_fc)
1248 {
1249 BT_ASSERT(dst_fc);
1250 BT_ASSERT(src_fc);
1251 dst_fc->elem_fc = ctf_field_class_copy(src_fc->elem_fc);
1252 dst_fc->is_text = src_fc->is_text;
1253 }
1254
1255 static inline
1256 struct ctf_field_class_array *_ctf_field_class_array_copy(
1257 struct ctf_field_class_array *fc)
1258 {
1259 struct ctf_field_class_array *copy_fc = ctf_field_class_array_create();
1260
1261 BT_ASSERT(copy_fc);
1262 ctf_field_class_array_base_copy_content((void *) copy_fc, (void *) fc);
1263 copy_fc->length = fc->length;
1264 return copy_fc;
1265 }
1266
1267 static inline
1268 struct ctf_field_class_sequence *_ctf_field_class_sequence_copy(
1269 struct ctf_field_class_sequence *fc)
1270 {
1271 struct ctf_field_class_sequence *copy_fc =
1272 ctf_field_class_sequence_create();
1273
1274 BT_ASSERT(copy_fc);
1275 ctf_field_class_array_base_copy_content((void *) copy_fc, (void *) fc);
1276 ctf_field_path_copy_content(&copy_fc->length_path, &fc->length_path);
1277 g_string_assign(copy_fc->length_ref, fc->length_ref->str);
1278 copy_fc->stored_length_index = fc->stored_length_index;
1279 return copy_fc;
1280 }
1281
1282 static inline
1283 struct ctf_field_class *ctf_field_class_copy(struct ctf_field_class *fc)
1284 {
1285 struct ctf_field_class *copy_fc = NULL;
1286
1287 if (!fc) {
1288 goto end;
1289 }
1290
1291 /*
1292 * Translation should not have happened yet.
1293 */
1294 BT_ASSERT(!fc->ir_fc);
1295
1296 switch (fc->type) {
1297 case CTF_FIELD_CLASS_TYPE_INT:
1298 copy_fc = (void *) _ctf_field_class_int_copy((void *) fc);
1299 break;
1300 case CTF_FIELD_CLASS_TYPE_ENUM:
1301 copy_fc = (void *) _ctf_field_class_enum_copy((void *) fc);
1302 break;
1303 case CTF_FIELD_CLASS_TYPE_FLOAT:
1304 copy_fc = (void *) _ctf_field_class_float_copy((void *) fc);
1305 break;
1306 case CTF_FIELD_CLASS_TYPE_STRING:
1307 copy_fc = (void *) _ctf_field_class_string_copy((void *) fc);
1308 break;
1309 case CTF_FIELD_CLASS_TYPE_STRUCT:
1310 copy_fc = (void *) _ctf_field_class_struct_copy((void *) fc);
1311 break;
1312 case CTF_FIELD_CLASS_TYPE_ARRAY:
1313 copy_fc = (void *) _ctf_field_class_array_copy((void *) fc);
1314 break;
1315 case CTF_FIELD_CLASS_TYPE_SEQUENCE:
1316 copy_fc = (void *) _ctf_field_class_sequence_copy((void *) fc);
1317 break;
1318 case CTF_FIELD_CLASS_TYPE_VARIANT:
1319 copy_fc = (void *) _ctf_field_class_variant_copy((void *) fc);
1320 break;
1321 default:
1322 abort();
1323 }
1324
1325 copy_fc->type = fc->type;
1326 copy_fc->alignment = fc->alignment;
1327 copy_fc->in_ir = fc->in_ir;
1328
1329 end:
1330 return copy_fc;
1331 }
1332
1333 static inline
1334 struct ctf_event_class *ctf_event_class_create(void)
1335 {
1336 struct ctf_event_class *ec = g_new0(struct ctf_event_class, 1);
1337
1338 BT_ASSERT(ec);
1339 ec->name = g_string_new(NULL);
1340 BT_ASSERT(ec->name);
1341 ec->emf_uri = g_string_new(NULL);
1342 BT_ASSERT(ec->emf_uri);
1343 ec->log_level = -1;
1344 return ec;
1345 }
1346
1347 static inline
1348 void ctf_event_class_destroy(struct ctf_event_class *ec)
1349 {
1350 if (!ec) {
1351 return;
1352 }
1353
1354 if (ec->name) {
1355 g_string_free(ec->name, TRUE);
1356 }
1357
1358 if (ec->emf_uri) {
1359 g_string_free(ec->emf_uri, TRUE);
1360 }
1361
1362 ctf_field_class_destroy(ec->spec_context_fc);
1363 ctf_field_class_destroy(ec->payload_fc);
1364 g_free(ec);
1365 }
1366
1367 static inline
1368 struct ctf_stream_class *ctf_stream_class_create(void)
1369 {
1370 struct ctf_stream_class *sc = g_new0(struct ctf_stream_class, 1);
1371
1372 BT_ASSERT(sc);
1373 sc->event_classes = g_ptr_array_new_with_free_func(
1374 (GDestroyNotify) ctf_event_class_destroy);
1375 BT_ASSERT(sc->event_classes);
1376 sc->event_classes_by_id = g_hash_table_new(g_direct_hash,
1377 g_direct_equal);
1378 BT_ASSERT(sc->event_classes_by_id);
1379 return sc;
1380 }
1381
1382 static inline
1383 void ctf_stream_class_destroy(struct ctf_stream_class *sc)
1384 {
1385 if (!sc) {
1386 return;
1387 }
1388
1389 if (sc->event_classes) {
1390 g_ptr_array_free(sc->event_classes, TRUE);
1391 }
1392
1393 if (sc->event_classes_by_id) {
1394 g_hash_table_destroy(sc->event_classes_by_id);
1395 }
1396
1397 ctf_field_class_destroy(sc->packet_context_fc);
1398 ctf_field_class_destroy(sc->event_header_fc);
1399 ctf_field_class_destroy(sc->event_common_context_fc);
1400 bt_clock_class_put_ref(sc->default_clock_class);
1401 g_free(sc);
1402 }
1403
1404 static inline
1405 void ctf_stream_class_append_event_class(struct ctf_stream_class *sc,
1406 struct ctf_event_class *ec)
1407 {
1408 g_ptr_array_add(sc->event_classes, ec);
1409 g_hash_table_insert(sc->event_classes_by_id,
1410 GUINT_TO_POINTER((guint) ec->id), ec);
1411 }
1412
1413 static inline
1414 struct ctf_event_class *ctf_stream_class_borrow_event_class_by_id(
1415 struct ctf_stream_class *sc, uint64_t type)
1416 {
1417 BT_ASSERT(sc);
1418 return g_hash_table_lookup(sc->event_classes_by_id,
1419 GUINT_TO_POINTER((guint) type));
1420 }
1421
1422 static inline
1423 void _ctf_trace_class_env_entry_init(struct ctf_trace_class_env_entry *entry)
1424 {
1425 BT_ASSERT(entry);
1426 entry->name = g_string_new(NULL);
1427 BT_ASSERT(entry->name);
1428 entry->value.str = g_string_new(NULL);
1429 BT_ASSERT(entry->value.str);
1430 }
1431
1432 static inline
1433 void _ctf_trace_class_env_entry_fini(struct ctf_trace_class_env_entry *entry)
1434 {
1435 BT_ASSERT(entry);
1436
1437 if (entry->name) {
1438 g_string_free(entry->name, TRUE);
1439 }
1440
1441 if (entry->value.str) {
1442 g_string_free(entry->value.str, TRUE);
1443 }
1444 }
1445
1446 static inline
1447 struct ctf_trace_class *ctf_trace_class_create(void)
1448 {
1449 struct ctf_trace_class *tc = g_new0(struct ctf_trace_class, 1);
1450
1451 BT_ASSERT(tc);
1452 tc->default_byte_order = -1;
1453 tc->clock_classes = g_ptr_array_new_with_free_func(
1454 (GDestroyNotify) bt_clock_class_put_ref);
1455 BT_ASSERT(tc->clock_classes);
1456 tc->stream_classes = g_ptr_array_new_with_free_func(
1457 (GDestroyNotify) ctf_stream_class_destroy);
1458 BT_ASSERT(tc->stream_classes);
1459 tc->env_entries = g_array_new(FALSE, TRUE,
1460 sizeof(struct ctf_trace_class_env_entry));
1461 return tc;
1462 }
1463
1464 static inline
1465 void ctf_trace_class_destroy(struct ctf_trace_class *tc)
1466 {
1467 if (!tc) {
1468 return;
1469 }
1470
1471 ctf_field_class_destroy(tc->packet_header_fc);
1472
1473 if (tc->clock_classes) {
1474 g_ptr_array_free(tc->clock_classes, TRUE);
1475 }
1476
1477 if (tc->stream_classes) {
1478 g_ptr_array_free(tc->stream_classes, TRUE);
1479 }
1480
1481 if (tc->env_entries) {
1482 uint64_t i;
1483
1484 for (i = 0; i < tc->env_entries->len; i++) {
1485 struct ctf_trace_class_env_entry *entry =
1486 &g_array_index(tc->env_entries,
1487 struct ctf_trace_class_env_entry, i);
1488
1489 _ctf_trace_class_env_entry_fini(entry);
1490 }
1491
1492 g_array_free(tc->env_entries, TRUE);
1493 }
1494
1495 g_free(tc);
1496 }
1497
1498 static inline
1499 void ctf_trace_class_append_env_entry(struct ctf_trace_class *tc,
1500 const char *name, enum ctf_trace_class_env_entry_type type,
1501 const char *str_value, int64_t i_value)
1502 {
1503 struct ctf_trace_class_env_entry *entry;
1504
1505 BT_ASSERT(tc);
1506 BT_ASSERT(name);
1507 g_array_set_size(tc->env_entries, tc->env_entries->len + 1);
1508
1509 entry = &g_array_index(tc->env_entries,
1510 struct ctf_trace_class_env_entry, tc->env_entries->len - 1);
1511 entry->type = type;
1512 _ctf_trace_class_env_entry_init(entry);
1513 g_string_assign(entry->name, name);
1514
1515 if (str_value) {
1516 g_string_assign(entry->value.str, str_value);
1517 }
1518
1519 entry->value.i = i_value;
1520 }
1521
1522 static inline
1523 struct ctf_stream_class *ctf_trace_class_borrow_stream_class_by_id(
1524 struct ctf_trace_class *tc, uint64_t id)
1525 {
1526 uint64_t i;
1527 struct ctf_stream_class *ret_sc = NULL;
1528
1529 BT_ASSERT(tc);
1530
1531 for (i = 0; i < tc->stream_classes->len; i++) {
1532 struct ctf_stream_class *sc = tc->stream_classes->pdata[i];
1533
1534 if (sc->id == id) {
1535 ret_sc = sc;
1536 goto end;
1537 }
1538 }
1539
1540 end:
1541 return ret_sc;
1542 }
1543
1544 static inline
1545 bt_clock_class *ctf_trace_class_borrow_clock_class_by_name(
1546 struct ctf_trace_class *tc, const char *name)
1547 {
1548 uint64_t i;
1549 bt_clock_class *ret_cc = NULL;
1550
1551 BT_ASSERT(tc);
1552 BT_ASSERT(name);
1553
1554 for (i = 0; i < tc->clock_classes->len; i++) {
1555 bt_clock_class *cc = tc->clock_classes->pdata[i];
1556 const char *cc_name = bt_clock_class_get_name(cc);
1557
1558 BT_ASSERT(cc_name);
1559 if (strcmp(cc_name, name) == 0) {
1560 ret_cc = cc;
1561 goto end;
1562 }
1563 }
1564
1565 end:
1566 return ret_cc;
1567 }
1568
1569 static inline
1570 struct ctf_trace_class_env_entry *ctf_trace_class_borrow_env_entry_by_index(
1571 struct ctf_trace_class *tc, uint64_t index)
1572 {
1573 BT_ASSERT(tc);
1574 BT_ASSERT(index < tc->env_entries->len);
1575 return &g_array_index(tc->env_entries, struct ctf_trace_class_env_entry,
1576 index);
1577 }
1578
1579 static inline
1580 struct ctf_trace_class_env_entry *ctf_trace_class_borrow_env_entry_by_name(
1581 struct ctf_trace_class *tc, const char *name)
1582 {
1583 struct ctf_trace_class_env_entry *ret_entry = NULL;
1584 uint64_t i;
1585
1586 BT_ASSERT(tc);
1587 BT_ASSERT(name);
1588
1589 for (i = 0; i < tc->env_entries->len; i++) {
1590 struct ctf_trace_class_env_entry *env_entry =
1591 ctf_trace_class_borrow_env_entry_by_index(tc, i);
1592
1593 if (strcmp(env_entry->name->str, name) == 0) {
1594 ret_entry = env_entry;
1595 goto end;
1596 }
1597 }
1598
1599 end:
1600 return ret_entry;
1601 }
1602
1603 #endif /* _CTF_META_H */
This page took 0.064327 seconds and 4 git commands to generate.