b6f349be9a6f7545292078460e7f6c2bdd3c94ff
[babeltrace.git] / src / cpp-common / bt2 / trace-ir.hpp
1 /*
2 * Copyright (c) 2020-2021 Philippe Proulx <pproulx@efficios.com>
3 *
4 * SPDX-License-Identifier: MIT
5 */
6
7 #ifndef BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
8 #define BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
9
10 #include <cstdint>
11 #include <type_traits>
12
13 #include <babeltrace2/babeltrace.h>
14
15 #include "cpp-common/optional.hpp"
16
17 #include "borrowed-object.hpp"
18 #include "clock-class.hpp"
19 #include "field-class.hpp"
20 #include "field.hpp"
21 #include "internal/utils.hpp"
22 #include "shared-object.hpp"
23 #include "value.hpp"
24
25 namespace bt2 {
26
27 template <typename LibObjT>
28 class CommonEvent;
29
30 template <typename LibObjT>
31 class CommonPacket;
32
33 template <typename LibObjT>
34 class CommonStream;
35
36 template <typename LibObjT>
37 class CommonTrace;
38
39 template <typename LibObjT>
40 class CommonEventClass;
41
42 template <typename LibObjT>
43 class CommonStreamClass;
44
45 template <typename LibObjT>
46 class CommonTraceClass;
47
48 namespace internal {
49
50 template <typename LibObjT>
51 struct CommonEventSpec;
52
53 /* Functions specific to mutable events */
54 template <>
55 struct CommonEventSpec<bt_event> final
56 {
57 static bt_event_class *cls(bt_event * const libObjPtr) noexcept
58 {
59 return bt_event_borrow_class(libObjPtr);
60 }
61
62 static bt_stream *stream(bt_event * const libObjPtr) noexcept
63 {
64 return bt_event_borrow_stream(libObjPtr);
65 }
66
67 static bt_packet *packet(bt_event * const libObjPtr) noexcept
68 {
69 return bt_event_borrow_packet(libObjPtr);
70 }
71
72 static bt_field *payloadField(bt_event * const libObjPtr) noexcept
73 {
74 return bt_event_borrow_payload_field(libObjPtr);
75 }
76
77 static bt_field *specificContextField(bt_event * const libObjPtr) noexcept
78 {
79 return bt_event_borrow_specific_context_field(libObjPtr);
80 }
81
82 static bt_field *commonContextField(bt_event * const libObjPtr) noexcept
83 {
84 return bt_event_borrow_common_context_field(libObjPtr);
85 }
86 };
87
88 /* Functions specific to constant events */
89 template <>
90 struct CommonEventSpec<const bt_event> final
91 {
92 static const bt_event_class *cls(const bt_event * const libObjPtr) noexcept
93 {
94 return bt_event_borrow_class_const(libObjPtr);
95 }
96
97 static const bt_stream *stream(const bt_event * const libObjPtr) noexcept
98 {
99 return bt_event_borrow_stream_const(libObjPtr);
100 }
101
102 static const bt_packet *packet(const bt_event * const libObjPtr) noexcept
103 {
104 return bt_event_borrow_packet_const(libObjPtr);
105 }
106
107 static const bt_field *payloadField(const bt_event * const libObjPtr) noexcept
108 {
109 return bt_event_borrow_payload_field_const(libObjPtr);
110 }
111
112 static const bt_field *specificContextField(const bt_event * const libObjPtr) noexcept
113 {
114 return bt_event_borrow_specific_context_field_const(libObjPtr);
115 }
116
117 static const bt_field *commonContextField(const bt_event * const libObjPtr) noexcept
118 {
119 return bt_event_borrow_common_context_field_const(libObjPtr);
120 }
121 };
122
123 template <typename LibObjT>
124 using DepStructField = DepType<LibObjT, StructureField, ConstStructureField>;
125
126 } /* namespace internal */
127
128 template <typename LibObjT>
129 class CommonEvent final : public BorrowedObject<LibObjT>
130 {
131 private:
132 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
133 using typename BorrowedObject<LibObjT>::_LibObjPtr;
134 using _Spec = internal::CommonEventSpec<LibObjT>;
135 using _Packet = internal::DepPacket<LibObjT>;
136 using _Stream = internal::DepStream<LibObjT>;
137 using _StructureField = internal::DepStructField<LibObjT>;
138
139 public:
140 using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
141 CommonEventClass<const bt_event_class>>;
142
143 explicit CommonEvent(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
144 {
145 }
146
147 template <typename OtherLibObjT>
148 CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
149 {
150 }
151
152 template <typename OtherLibObjT>
153 CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
154 {
155 _ThisBorrowedObject::operator=(event);
156 return *this;
157 }
158
159 CommonEvent<const bt_event> asConst() const noexcept
160 {
161 return CommonEvent<const bt_event> {*this};
162 }
163
164 Class cls() const noexcept;
165 _Stream stream() const noexcept;
166 nonstd::optional<_Packet> packet() const noexcept;
167
168 nonstd::optional<_StructureField> payloadField() const noexcept
169 {
170 const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
171
172 if (libObjPtr) {
173 return _StructureField {libObjPtr};
174 }
175
176 return nonstd::nullopt;
177 }
178
179 nonstd::optional<_StructureField> specificContextField() const noexcept
180 {
181 const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
182
183 if (libObjPtr) {
184 return _StructureField {libObjPtr};
185 }
186
187 return nonstd::nullopt;
188 }
189
190 nonstd::optional<_StructureField> commonContextField() const noexcept
191 {
192 const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
193
194 if (libObjPtr) {
195 return _StructureField {libObjPtr};
196 }
197
198 return nonstd::nullopt;
199 }
200 };
201
202 using Event = CommonEvent<bt_event>;
203 using ConstEvent = CommonEvent<const bt_event>;
204
205 namespace internal {
206
207 struct EventTypeDescr
208 {
209 using Const = ConstEvent;
210 using NonConst = Event;
211 };
212
213 template <>
214 struct TypeDescr<Event> : public EventTypeDescr
215 {
216 };
217
218 template <>
219 struct TypeDescr<ConstEvent> : public EventTypeDescr
220 {
221 };
222
223 struct PacketRefFuncs final
224 {
225 static void get(const bt_packet * const libObjPtr) noexcept
226 {
227 bt_packet_get_ref(libObjPtr);
228 }
229
230 static void put(const bt_packet * const libObjPtr) noexcept
231 {
232 bt_packet_put_ref(libObjPtr);
233 }
234 };
235
236 template <typename LibObjT>
237 struct CommonPacketSpec;
238
239 /* Functions specific to mutable packets */
240 template <>
241 struct CommonPacketSpec<bt_packet> final
242 {
243 static bt_stream *stream(bt_packet * const libObjPtr) noexcept
244 {
245 return bt_packet_borrow_stream(libObjPtr);
246 }
247
248 static bt_field *contextField(bt_packet * const libObjPtr) noexcept
249 {
250 return bt_packet_borrow_context_field(libObjPtr);
251 }
252 };
253
254 /* Functions specific to constant packets */
255 template <>
256 struct CommonPacketSpec<const bt_packet> final
257 {
258 static const bt_stream *stream(const bt_packet * const libObjPtr) noexcept
259 {
260 return bt_packet_borrow_stream_const(libObjPtr);
261 }
262
263 static const bt_field *contextField(const bt_packet * const libObjPtr) noexcept
264 {
265 return bt_packet_borrow_context_field_const(libObjPtr);
266 }
267 };
268
269 } /* namespace internal */
270
271 template <typename LibObjT>
272 class CommonPacket final : public BorrowedObject<LibObjT>
273 {
274 private:
275 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
276 using typename BorrowedObject<LibObjT>::_LibObjPtr;
277 using _Spec = internal::CommonPacketSpec<LibObjT>;
278 using _Stream = internal::DepStream<LibObjT>;
279 using _StructureField = internal::DepStructField<LibObjT>;
280
281 public:
282 using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
283
284 explicit CommonPacket(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
285 {
286 }
287
288 template <typename OtherLibObjT>
289 CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
290 {
291 }
292
293 template <typename OtherLibObjT>
294 CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
295 {
296 _ThisBorrowedObject::operator=(packet);
297 return *this;
298 }
299
300 CommonPacket<const bt_packet> asConst() const noexcept
301 {
302 return CommonPacket<const bt_packet> {*this};
303 }
304
305 _Stream stream() const noexcept;
306
307 nonstd::optional<_StructureField> contextField() const noexcept
308 {
309 const auto libObjPtr = _Spec::contextField(this->libObjPtr());
310
311 if (libObjPtr) {
312 return _StructureField {libObjPtr};
313 }
314
315 return nonstd::nullopt;
316 }
317
318 Shared shared() const noexcept
319 {
320 return Shared::createWithRef(*this);
321 }
322 };
323
324 using Packet = CommonPacket<bt_packet>;
325 using ConstPacket = CommonPacket<const bt_packet>;
326
327 namespace internal {
328
329 struct PacketTypeDescr
330 {
331 using Const = ConstPacket;
332 using NonConst = Packet;
333 };
334
335 template <>
336 struct TypeDescr<Packet> : public PacketTypeDescr
337 {
338 };
339
340 template <>
341 struct TypeDescr<ConstPacket> : public PacketTypeDescr
342 {
343 };
344
345 } /* namespace internal */
346
347 template <typename LibObjT>
348 nonstd::optional<typename CommonEvent<LibObjT>::_Packet>
349 CommonEvent<LibObjT>::packet() const noexcept
350 {
351 const auto libObjPtr = _Spec::packet(this->libObjPtr());
352
353 if (libObjPtr) {
354 return _Packet {libObjPtr};
355 }
356
357 return nonstd::nullopt;
358 }
359
360 namespace internal {
361
362 struct StreamRefFuncs final
363 {
364 static void get(const bt_stream * const libObjPtr) noexcept
365 {
366 bt_stream_get_ref(libObjPtr);
367 }
368
369 static void put(const bt_stream * const libObjPtr) noexcept
370 {
371 bt_stream_put_ref(libObjPtr);
372 }
373 };
374
375 template <typename LibObjT>
376 struct CommonStreamSpec;
377
378 /* Functions specific to mutable streams */
379 template <>
380 struct CommonStreamSpec<bt_stream> final
381 {
382 static bt_stream_class *cls(bt_stream * const libObjPtr) noexcept
383 {
384 return bt_stream_borrow_class(libObjPtr);
385 }
386
387 static bt_trace *trace(bt_stream * const libObjPtr) noexcept
388 {
389 return bt_stream_borrow_trace(libObjPtr);
390 }
391
392 static bt_value *userAttributes(bt_stream * const libObjPtr) noexcept
393 {
394 return bt_stream_borrow_user_attributes(libObjPtr);
395 }
396 };
397
398 /* Functions specific to constant streams */
399 template <>
400 struct CommonStreamSpec<const bt_stream> final
401 {
402 static const bt_stream_class *cls(const bt_stream * const libObjPtr) noexcept
403 {
404 return bt_stream_borrow_class_const(libObjPtr);
405 }
406
407 static const bt_trace *trace(const bt_stream * const libObjPtr) noexcept
408 {
409 return bt_stream_borrow_trace_const(libObjPtr);
410 }
411
412 static const bt_value *userAttributes(const bt_stream * const libObjPtr) noexcept
413 {
414 return bt_stream_borrow_user_attributes_const(libObjPtr);
415 }
416 };
417
418 } /* namespace internal */
419
420 template <typename LibObjT>
421 class CommonStream final : public BorrowedObject<LibObjT>
422 {
423 private:
424 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
425 using typename BorrowedObject<LibObjT>::_LibObjPtr;
426 using _Spec = internal::CommonStreamSpec<LibObjT>;
427 using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
428
429 public:
430 using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
431 using UserAttributes = internal::DepUserAttrs<LibObjT>;
432
433 using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
434 CommonStreamClass<const bt_stream_class>>;
435
436 explicit CommonStream(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
437 {
438 }
439
440 template <typename OtherLibObjT>
441 CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObject {stream}
442 {
443 }
444
445 template <typename OtherLibObjT>
446 CommonStream operator=(const CommonStream<OtherLibObjT> stream) noexcept
447 {
448 _ThisBorrowedObject::operator=(stream);
449 return *this;
450 }
451
452 CommonStream<const bt_stream> asConst() const noexcept
453 {
454 return CommonStream<const bt_stream> {*this};
455 }
456
457 Packet::Shared createPacket() const
458 {
459 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
460
461 const auto libObjPtr = bt_packet_create(this->libObjPtr());
462
463 internal::validateCreatedObjPtr(libObjPtr);
464 return Packet::Shared::createWithoutRef(libObjPtr);
465 }
466
467 Class cls() const noexcept;
468 _Trace trace() const noexcept;
469
470 std::uint64_t id() const noexcept
471 {
472 return bt_stream_get_id(this->libObjPtr());
473 }
474
475 void name(const char * const name) const
476 {
477 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
478
479 const auto status = bt_stream_set_name(this->libObjPtr(), name);
480
481 if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
482 throw MemoryError {};
483 }
484 }
485
486 void name(const std::string& name) const
487 {
488 this->name(name.data());
489 }
490
491 const char *name() const noexcept
492 {
493 return bt_stream_get_name(this->libObjPtr());
494 }
495
496 template <typename LibValT>
497 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
498 {
499 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
500
501 bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
502 }
503
504 UserAttributes userAttributes() const noexcept
505 {
506 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
507 }
508
509 Shared shared() const noexcept
510 {
511 return Shared::createWithRef(*this);
512 }
513 };
514
515 using Stream = CommonStream<bt_stream>;
516 using ConstStream = CommonStream<const bt_stream>;
517
518 namespace internal {
519
520 struct StreamTypeDescr
521 {
522 using Const = ConstStream;
523 using NonConst = Stream;
524 };
525
526 template <>
527 struct TypeDescr<Stream> : public StreamTypeDescr
528 {
529 };
530
531 template <>
532 struct TypeDescr<ConstStream> : public StreamTypeDescr
533 {
534 };
535
536 } /* namespace internal */
537
538 template <typename LibObjT>
539 typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
540 {
541 return _Stream {_Spec::stream(this->libObjPtr())};
542 }
543
544 template <typename LibObjT>
545 typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
546 {
547 return _Stream {_Spec::stream(this->libObjPtr())};
548 }
549
550 namespace internal {
551
552 struct TraceRefFuncs final
553 {
554 static void get(const bt_trace * const libObjPtr) noexcept
555 {
556 bt_trace_get_ref(libObjPtr);
557 }
558
559 static void put(const bt_trace * const libObjPtr) noexcept
560 {
561 bt_trace_put_ref(libObjPtr);
562 }
563 };
564
565 template <typename LibObjT>
566 struct CommonTraceSpec;
567
568 /* Functions specific to mutable traces */
569 template <>
570 struct CommonTraceSpec<bt_trace> final
571 {
572 static bt_trace_class *cls(bt_trace * const libObjPtr) noexcept
573 {
574 return bt_trace_borrow_class(libObjPtr);
575 }
576
577 static bt_stream *streamByIndex(bt_trace * const libObjPtr, const std::uint64_t index) noexcept
578 {
579 return bt_trace_borrow_stream_by_index(libObjPtr, index);
580 }
581
582 static bt_stream *streamById(bt_trace * const libObjPtr, const std::uint64_t id) noexcept
583 {
584 return bt_trace_borrow_stream_by_id(libObjPtr, id);
585 }
586
587 static bt_value *userAttributes(bt_trace * const libObjPtr) noexcept
588 {
589 return bt_trace_borrow_user_attributes(libObjPtr);
590 }
591 };
592
593 /* Functions specific to constant traces */
594 template <>
595 struct CommonTraceSpec<const bt_trace> final
596 {
597 static const bt_trace_class *cls(const bt_trace * const libObjPtr) noexcept
598 {
599 return bt_trace_borrow_class_const(libObjPtr);
600 }
601
602 static const bt_stream *streamByIndex(const bt_trace * const libObjPtr,
603 const std::uint64_t index) noexcept
604 {
605 return bt_trace_borrow_stream_by_index_const(libObjPtr, index);
606 }
607
608 static const bt_stream *streamById(const bt_trace * const libObjPtr,
609 const std::uint64_t id) noexcept
610 {
611 return bt_trace_borrow_stream_by_id_const(libObjPtr, id);
612 }
613
614 static const bt_value *userAttributes(const bt_trace * const libObjPtr) noexcept
615 {
616 return bt_trace_borrow_user_attributes_const(libObjPtr);
617 }
618 };
619
620 } /* namespace internal */
621
622 template <typename LibObjT>
623 class CommonTrace final : public BorrowedObject<LibObjT>
624 {
625 private:
626 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
627 using typename BorrowedObject<LibObjT>::_LibObjPtr;
628 using _Spec = internal::CommonTraceSpec<LibObjT>;
629 using _Stream = internal::DepStream<LibObjT>;
630
631 public:
632 using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
633 using UserAttributes = internal::DepUserAttrs<LibObjT>;
634
635 using Class = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
636 CommonTraceClass<const bt_trace_class>>;
637
638 struct ConstEnvironmentEntry
639 {
640 const char *name;
641 ConstValue value;
642 };
643
644 explicit CommonTrace(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
645 {
646 }
647
648 template <typename OtherLibObjT>
649 CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObject {trace}
650 {
651 }
652
653 template <typename OtherLibObjT>
654 CommonTrace operator=(const CommonTrace<OtherLibObjT> trace) noexcept
655 {
656 _ThisBorrowedObject::operator=(trace);
657 return *this;
658 }
659
660 CommonTrace<const bt_trace> asConst() const noexcept
661 {
662 return CommonTrace<const bt_trace> {*this};
663 }
664
665 Class cls() const noexcept;
666
667 void name(const char * const name) const
668 {
669 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
670
671 const auto status = bt_trace_set_name(this->libObjPtr(), name);
672
673 if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
674 throw MemoryError {};
675 }
676 }
677
678 void name(const std::string& name) const
679 {
680 this->name(name.data());
681 }
682
683 const char *name() const noexcept
684 {
685 return bt_trace_get_name(this->libObjPtr());
686 }
687
688 void uuid(const bt2_common::UuidView& uuid) const noexcept
689 {
690 bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
691 }
692
693 nonstd::optional<bt2_common::UuidView> uuid() const noexcept
694 {
695 const auto uuid = bt_trace_get_uuid(this->libObjPtr());
696
697 if (uuid) {
698 return bt2_common::UuidView {uuid};
699 }
700
701 return nonstd::nullopt;
702 }
703
704 std::uint64_t length() const noexcept
705 {
706 return bt_trace_get_stream_count(this->libObjPtr());
707 }
708
709 _Stream operator[](const std::uint64_t index) const noexcept
710 {
711 return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
712 }
713
714 nonstd::optional<_Stream> streamById(const std::uint64_t id) const noexcept
715 {
716 const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
717
718 if (libObjPtr) {
719 return _Stream {libObjPtr};
720 }
721
722 return nonstd::nullopt;
723 }
724
725 void environmentEntry(const char * const name, const std::int64_t val) const
726 {
727 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
728
729 const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
730
731 if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
732 throw MemoryError {};
733 }
734 }
735
736 void environmentEntry(const std::string& name, const std::int64_t val) const
737 {
738 this->environmentEntry(name.data(), val);
739 }
740
741 void environmentEntry(const char * const name, const char * const val) const
742 {
743 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
744
745 const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
746
747 if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
748 throw MemoryError {};
749 }
750 }
751
752 void environmentEntry(const std::string& name, const char * const val) const
753 {
754 this->environmentEntry(name.data(), val);
755 }
756
757 void environmentEntry(const char * const name, const std::string& val) const
758 {
759 this->environmentEntry(name, val.data());
760 }
761
762 void environmentEntry(const std::string& name, const std::string& val) const
763 {
764 this->environmentEntry(name.data(), val.data());
765 }
766
767 std::uint64_t environmentSize() const noexcept
768 {
769 return bt_trace_get_environment_entry_count(this->libObjPtr());
770 }
771
772 ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
773 {
774 const char *name;
775 const bt_value *libObjPtr;
776
777 bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
778 &libObjPtr);
779 return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
780 }
781
782 nonstd::optional<ConstValue> environmentEntry(const char * const name) const noexcept
783 {
784 const auto libObjPtr =
785 bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
786
787 if (libObjPtr) {
788 return ConstValue {libObjPtr};
789 }
790
791 return nonstd::nullopt;
792 }
793
794 nonstd::optional<ConstValue> environmentEntry(const std::string& name) const noexcept
795 {
796 return this->environmentEntry(name.data());
797 }
798
799 template <typename LibValT>
800 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
801 {
802 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
803
804 bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
805 }
806
807 UserAttributes userAttributes() const noexcept
808 {
809 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
810 }
811
812 Shared shared() const noexcept
813 {
814 return Shared::createWithRef(*this);
815 }
816 };
817
818 using Trace = CommonTrace<bt_trace>;
819 using ConstTrace = CommonTrace<const bt_trace>;
820
821 namespace internal {
822
823 struct TraceTypeDescr
824 {
825 using Const = ConstTrace;
826 using NonConst = Trace;
827 };
828
829 template <>
830 struct TypeDescr<Trace> : public TraceTypeDescr
831 {
832 };
833
834 template <>
835 struct TypeDescr<ConstTrace> : public TraceTypeDescr
836 {
837 };
838
839 } /* namespace internal */
840
841 template <typename LibObjT>
842 typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
843 {
844 return _Trace {_Spec::trace(this->libObjPtr())};
845 }
846
847 namespace internal {
848
849 struct EventClassRefFuncs final
850 {
851 static void get(const bt_event_class * const libObjPtr) noexcept
852 {
853 bt_event_class_get_ref(libObjPtr);
854 }
855
856 static void put(const bt_event_class * const libObjPtr) noexcept
857 {
858 bt_event_class_put_ref(libObjPtr);
859 }
860 };
861
862 template <typename LibObjT>
863 struct CommonEventClassSpec;
864
865 /* Functions specific to mutable event classes */
866 template <>
867 struct CommonEventClassSpec<bt_event_class> final
868 {
869 static bt_stream_class *streamClass(bt_event_class * const libObjPtr) noexcept
870 {
871 return bt_event_class_borrow_stream_class(libObjPtr);
872 }
873
874 static bt_field_class *payloadFieldClass(bt_event_class * const libObjPtr) noexcept
875 {
876 return bt_event_class_borrow_payload_field_class(libObjPtr);
877 }
878
879 static bt_field_class *specificContextFieldClass(bt_event_class * const libObjPtr) noexcept
880 {
881 return bt_event_class_borrow_specific_context_field_class(libObjPtr);
882 }
883
884 static bt_value *userAttributes(bt_event_class * const libObjPtr) noexcept
885 {
886 return bt_event_class_borrow_user_attributes(libObjPtr);
887 }
888 };
889
890 /* Functions specific to constant event classes */
891 template <>
892 struct CommonEventClassSpec<const bt_event_class> final
893 {
894 static const bt_stream_class *streamClass(const bt_event_class * const libObjPtr) noexcept
895 {
896 return bt_event_class_borrow_stream_class_const(libObjPtr);
897 }
898
899 static const bt_field_class *payloadFieldClass(const bt_event_class * const libObjPtr) noexcept
900 {
901 return bt_event_class_borrow_payload_field_class_const(libObjPtr);
902 }
903
904 static const bt_field_class *
905 specificContextFieldClass(const bt_event_class * const libObjPtr) noexcept
906 {
907 return bt_event_class_borrow_specific_context_field_class_const(libObjPtr);
908 }
909
910 static const bt_value *userAttributes(const bt_event_class * const libObjPtr) noexcept
911 {
912 return bt_event_class_borrow_user_attributes_const(libObjPtr);
913 }
914 };
915
916 template <typename LibObjT>
917 using DepStructFc = DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
918
919 } /* namespace internal */
920
921 template <typename LibObjT>
922 class CommonEventClass final : public BorrowedObject<LibObjT>
923 {
924 private:
925 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
926 using typename BorrowedObject<LibObjT>::_LibObjPtr;
927 using _Spec = internal::CommonEventClassSpec<LibObjT>;
928 using _StructureFieldClass = internal::DepStructFc<LibObjT>;
929
930 using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
931 CommonStreamClass<const bt_stream_class>>;
932
933 public:
934 using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
935 using UserAttributes = internal::DepUserAttrs<LibObjT>;
936
937 enum class LogLevel
938 {
939 EMERGENCY = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
940 ALERT = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
941 CRITICAL = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
942 ERR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
943 WARNING = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
944 NOTICE = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
945 INFO = BT_EVENT_CLASS_LOG_LEVEL_INFO,
946 DEBUG_SYSTEM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
947 DEBUG_PROGRAM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
948 DEBUG_PROC = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
949 DEBUG_MODULE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
950 DEBUG_UNIT = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
951 DEBUG_FUNCTION = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
952 DEBUG_LINE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
953 DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
954 };
955
956 explicit CommonEventClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
957 {
958 }
959
960 template <typename OtherLibObjT>
961 CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
962 _ThisBorrowedObject {eventClass}
963 {
964 }
965
966 template <typename OtherLibObjT>
967 CommonEventClass operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
968 {
969 _ThisBorrowedObject::operator=(eventClass);
970 return *this;
971 }
972
973 CommonEventClass<const bt_event_class> asConst() const noexcept
974 {
975 return CommonEventClass<const bt_event_class> {*this};
976 }
977
978 _StreamClass streamClass() const noexcept;
979
980 std::uint64_t id() const noexcept
981 {
982 return bt_event_class_get_id(this->libObjPtr());
983 }
984
985 void name(const char * const name) const
986 {
987 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
988
989 const auto status = bt_event_class_set_name(this->libObjPtr(), name);
990
991 if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
992 throw MemoryError {};
993 }
994 }
995
996 void name(const std::string& name) const
997 {
998 this->name(name.data());
999 }
1000
1001 const char *name() const noexcept
1002 {
1003 return bt_event_class_get_name(this->libObjPtr());
1004 }
1005
1006 void logLevel(const LogLevel logLevel) const noexcept
1007 {
1008 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1009
1010 bt_event_class_set_log_level(this->libObjPtr(),
1011 static_cast<bt_event_class_log_level>(logLevel));
1012 }
1013
1014 nonstd::optional<LogLevel> logLevel() const noexcept
1015 {
1016 bt_event_class_log_level libLogLevel;
1017 const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
1018
1019 if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
1020 return static_cast<LogLevel>(libLogLevel);
1021 }
1022
1023 return nonstd::nullopt;
1024 }
1025
1026 void emfUri(const char * const emfUri) const
1027 {
1028 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1029
1030 const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
1031
1032 if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
1033 throw MemoryError {};
1034 }
1035 }
1036
1037 void emfUri(const std::string& emfUri) const
1038 {
1039 this->emfUri(emfUri.data());
1040 }
1041
1042 const char *emfUri() const noexcept
1043 {
1044 return bt_event_class_get_emf_uri(this->libObjPtr());
1045 }
1046
1047 void payloadFieldClass(const StructureFieldClass fc) const
1048 {
1049 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1050
1051 const auto status =
1052 bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
1053
1054 if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1055 throw MemoryError {};
1056 }
1057 }
1058
1059 nonstd::optional<_StructureFieldClass> payloadFieldClass() const noexcept
1060 {
1061 const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
1062
1063 if (libObjPtr) {
1064 return _StructureFieldClass {libObjPtr};
1065 }
1066
1067 return nonstd::nullopt;
1068 }
1069
1070 void specificContextFieldClass(const StructureFieldClass fc) const
1071 {
1072 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1073
1074 const auto status =
1075 bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
1076
1077 if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1078 throw MemoryError {};
1079 }
1080 }
1081
1082 nonstd::optional<_StructureFieldClass> specificContextFieldClass() const noexcept
1083 {
1084 const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
1085
1086 if (libObjPtr) {
1087 return _StructureFieldClass {libObjPtr};
1088 }
1089
1090 return nonstd::nullopt;
1091 }
1092
1093 template <typename LibValT>
1094 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1095 {
1096 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1097
1098 bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1099 }
1100
1101 UserAttributes userAttributes() const noexcept
1102 {
1103 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1104 }
1105
1106 Shared shared() const noexcept
1107 {
1108 return Shared::createWithRef(*this);
1109 }
1110 };
1111
1112 using EventClass = CommonEventClass<bt_event_class>;
1113 using ConstEventClass = CommonEventClass<const bt_event_class>;
1114
1115 namespace internal {
1116
1117 struct EventClassTypeDescr
1118 {
1119 using Const = ConstEventClass;
1120 using NonConst = EventClass;
1121 };
1122
1123 template <>
1124 struct TypeDescr<EventClass> : public EventClassTypeDescr
1125 {
1126 };
1127
1128 template <>
1129 struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
1130 {
1131 };
1132
1133 } /* namespace internal */
1134
1135 template <typename LibObjT>
1136 typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
1137 {
1138 return Class {_Spec::cls(this->libObjPtr())};
1139 }
1140
1141 namespace internal {
1142
1143 struct StreamClassRefFuncs final
1144 {
1145 static void get(const bt_stream_class * const libObjPtr) noexcept
1146 {
1147 bt_stream_class_get_ref(libObjPtr);
1148 }
1149
1150 static void put(const bt_stream_class * const libObjPtr) noexcept
1151 {
1152 bt_stream_class_put_ref(libObjPtr);
1153 }
1154 };
1155
1156 template <typename LibObjT>
1157 struct CommonStreamClassSpec;
1158
1159 /* Functions specific to mutable stream classes */
1160 template <>
1161 struct CommonStreamClassSpec<bt_stream_class> final
1162 {
1163 static bt_trace_class *traceClass(bt_stream_class * const libObjPtr) noexcept
1164 {
1165 return bt_stream_class_borrow_trace_class(libObjPtr);
1166 }
1167
1168 static bt_event_class *eventClassByIndex(bt_stream_class * const libObjPtr,
1169 const std::uint64_t index) noexcept
1170 {
1171 return bt_stream_class_borrow_event_class_by_index(libObjPtr, index);
1172 }
1173
1174 static bt_event_class *eventClassById(bt_stream_class * const libObjPtr,
1175 const std::uint64_t id) noexcept
1176 {
1177 return bt_stream_class_borrow_event_class_by_id(libObjPtr, id);
1178 }
1179
1180 static bt_clock_class *defaultClockClass(bt_stream_class * const libObjPtr) noexcept
1181 {
1182 return bt_stream_class_borrow_default_clock_class(libObjPtr);
1183 }
1184
1185 static bt_field_class *packetContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1186 {
1187 return bt_stream_class_borrow_packet_context_field_class(libObjPtr);
1188 }
1189
1190 static bt_field_class *eventCommonContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1191 {
1192 return bt_stream_class_borrow_event_common_context_field_class(libObjPtr);
1193 }
1194
1195 static bt_value *userAttributes(bt_stream_class * const libObjPtr) noexcept
1196 {
1197 return bt_stream_class_borrow_user_attributes(libObjPtr);
1198 }
1199 };
1200
1201 /* Functions specific to constant stream classes */
1202 template <>
1203 struct CommonStreamClassSpec<const bt_stream_class> final
1204 {
1205 static const bt_trace_class *traceClass(const bt_stream_class * const libObjPtr) noexcept
1206 {
1207 return bt_stream_class_borrow_trace_class_const(libObjPtr);
1208 }
1209
1210 static const bt_event_class *eventClassByIndex(const bt_stream_class * const libObjPtr,
1211 const std::uint64_t index) noexcept
1212 {
1213 return bt_stream_class_borrow_event_class_by_index_const(libObjPtr, index);
1214 }
1215
1216 static const bt_event_class *eventClassById(const bt_stream_class * const libObjPtr,
1217 const std::uint64_t id) noexcept
1218 {
1219 return bt_stream_class_borrow_event_class_by_id_const(libObjPtr, id);
1220 }
1221
1222 static const bt_clock_class *defaultClockClass(const bt_stream_class * const libObjPtr) noexcept
1223 {
1224 return bt_stream_class_borrow_default_clock_class_const(libObjPtr);
1225 }
1226
1227 static const bt_field_class *
1228 packetContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1229 {
1230 return bt_stream_class_borrow_packet_context_field_class_const(libObjPtr);
1231 }
1232
1233 static const bt_field_class *
1234 eventCommonContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1235 {
1236 return bt_stream_class_borrow_event_common_context_field_class_const(libObjPtr);
1237 }
1238
1239 static const bt_value *userAttributes(const bt_stream_class * const libObjPtr) noexcept
1240 {
1241 return bt_stream_class_borrow_user_attributes_const(libObjPtr);
1242 }
1243 };
1244
1245 } /* namespace internal */
1246
1247 template <typename LibObjT>
1248 class CommonStreamClass final : public BorrowedObject<LibObjT>
1249 {
1250 private:
1251 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1252 using typename BorrowedObject<LibObjT>::_LibObjPtr;
1253 using _Spec = internal::CommonStreamClassSpec<LibObjT>;
1254 using _StructureFieldClass = internal::DepStructFc<LibObjT>;
1255
1256 using _TraceClass = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
1257 CommonTraceClass<const bt_trace_class>>;
1258
1259 using _EventClass = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
1260 CommonEventClass<const bt_event_class>>;
1261
1262 using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
1263
1264 public:
1265 using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
1266 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1267
1268 explicit CommonStreamClass(const _LibObjPtr libObjPtr) noexcept :
1269 _ThisBorrowedObject {libObjPtr}
1270 {
1271 }
1272
1273 template <typename OtherLibObjT>
1274 CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
1275 _ThisBorrowedObject {streamClass}
1276 {
1277 }
1278
1279 template <typename OtherLibObjT>
1280 CommonStreamClass operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
1281 {
1282 _ThisBorrowedObject::operator=(streamClass);
1283 return *this;
1284 }
1285
1286 CommonStreamClass<const bt_stream_class> asConst() const noexcept
1287 {
1288 return CommonStreamClass<const bt_stream_class> {*this};
1289 }
1290
1291 Stream::Shared instantiate(const Trace trace) const
1292 {
1293 static_assert(!std::is_const<LibObjT>::value,
1294 "Not available with `bt2::ConstStreamClass`.");
1295
1296 const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
1297
1298 internal::validateCreatedObjPtr(libObjPtr);
1299 return Stream::Shared::createWithoutRef(libObjPtr);
1300 }
1301
1302 Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
1303 {
1304 static_assert(!std::is_const<LibObjT>::value,
1305 "Not available with `bt2::ConstStreamClass`.");
1306
1307 const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
1308
1309 internal::validateCreatedObjPtr(libObjPtr);
1310 return Stream::Shared::createWithoutRef(libObjPtr);
1311 }
1312
1313 EventClass::Shared createEventClass() const
1314 {
1315 static_assert(!std::is_const<LibObjT>::value,
1316 "Not available with `bt2::ConstStreamClass`.");
1317
1318 const auto libObjPtr = bt_event_class_create(this->libObjPtr());
1319
1320 internal::validateCreatedObjPtr(libObjPtr);
1321 return EventClass::Shared::createWithoutRef(libObjPtr);
1322 }
1323
1324 EventClass::Shared createEventClass(const std::uint64_t id) const
1325 {
1326 static_assert(!std::is_const<LibObjT>::value,
1327 "Not available with `bt2::ConstStreamClass`.");
1328
1329 const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
1330
1331 internal::validateCreatedObjPtr(libObjPtr);
1332 return EventClass::Shared::createWithoutRef(libObjPtr);
1333 }
1334
1335 _TraceClass traceClass() const noexcept;
1336
1337 std::uint64_t id() const noexcept
1338 {
1339 return bt_stream_class_get_id(this->libObjPtr());
1340 }
1341
1342 void name(const char * const name) const
1343 {
1344 static_assert(!std::is_const<LibObjT>::value,
1345 "Not available with `bt2::ConstStreamClass`.");
1346
1347 const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
1348
1349 if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
1350 throw MemoryError {};
1351 }
1352 }
1353
1354 void name(const std::string& name) const
1355 {
1356 this->name(name.data());
1357 }
1358
1359 const char *name() const noexcept
1360 {
1361 return bt_stream_class_get_name(this->libObjPtr());
1362 }
1363
1364 void assignsAutomaticEventClassId(const bool val) const noexcept
1365 {
1366 static_assert(!std::is_const<LibObjT>::value,
1367 "Not available with `bt2::ConstStreamClass`.");
1368
1369 bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
1370 static_cast<bt_bool>(val));
1371 }
1372
1373 bool assignsAutomaticEventClassId() const noexcept
1374 {
1375 return static_cast<bool>(
1376 bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
1377 }
1378
1379 void assignsAutomaticStreamId(const bool val) const noexcept
1380 {
1381 static_assert(!std::is_const<LibObjT>::value,
1382 "Not available with `bt2::ConstStreamClass`.");
1383
1384 bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
1385 static_cast<bt_bool>(val));
1386 }
1387
1388 bool assignsAutomaticStreamId() const noexcept
1389 {
1390 return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
1391 }
1392
1393 void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
1394 const bool withEndDefaultClkSnapshot) const noexcept
1395 {
1396 static_assert(!std::is_const<LibObjT>::value,
1397 "Not available with `bt2::ConstStreamClass`.");
1398
1399 bt_stream_class_set_supports_packets(this->libObjPtr(),
1400 static_cast<bt_bool>(supportsPackets),
1401 static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
1402 static_cast<bt_bool>(withEndDefaultClkSnapshot));
1403 }
1404
1405 bool supportsPackets() const noexcept
1406 {
1407 return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
1408 }
1409
1410 bool packetsHaveBeginningClockSnapshot() const noexcept
1411 {
1412 return static_cast<bool>(
1413 bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
1414 }
1415
1416 bool packetsHaveEndClockSnapshot() const noexcept
1417 {
1418 return static_cast<bool>(
1419 bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
1420 }
1421
1422 void supportsDiscardedEvents(const bool supportsDiscardedEvents,
1423 const bool withDefaultClkSnapshots) const noexcept
1424 {
1425 static_assert(!std::is_const<LibObjT>::value,
1426 "Not available with `bt2::ConstStreamClass`.");
1427
1428 bt_stream_class_set_supports_discarded_events(
1429 this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedEvents),
1430 static_cast<bt_bool>(withDefaultClkSnapshots));
1431 }
1432
1433 bool supportsDiscardedEvents() const noexcept
1434 {
1435 return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
1436 }
1437
1438 bool discardedEventsHaveDefaultClockSnapshots() const noexcept
1439 {
1440 return static_cast<bool>(
1441 bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
1442 }
1443
1444 void supportsDiscardedPackets(const bool supportsDiscardedPackets,
1445 const bool withDefaultClkSnapshots) const noexcept
1446 {
1447 static_assert(!std::is_const<LibObjT>::value,
1448 "Not available with `bt2::ConstStreamClass`.");
1449
1450 bt_stream_class_set_supports_discarded_packets(
1451 this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedPackets),
1452 static_cast<bt_bool>(withDefaultClkSnapshots));
1453 }
1454
1455 bool supportsDiscardedPackets() const noexcept
1456 {
1457 return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
1458 }
1459
1460 bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
1461 {
1462 return static_cast<bool>(
1463 bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
1464 }
1465
1466 void defaultClockClass(const ClockClass clkCls) const
1467 {
1468 static_assert(!std::is_const<LibObjT>::value,
1469 "Not available with `bt2::ConstStreamClass`.");
1470
1471 const auto status =
1472 bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
1473
1474 BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
1475 }
1476
1477 nonstd::optional<_ClockClass> defaultClockClass() const noexcept
1478 {
1479 const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
1480
1481 if (libObjPtr) {
1482 return _ClockClass {libObjPtr};
1483 }
1484
1485 return nonstd::nullopt;
1486 }
1487
1488 std::uint64_t length() const noexcept
1489 {
1490 return bt_stream_class_get_event_class_count(this->libObjPtr());
1491 }
1492
1493 _EventClass operator[](const std::uint64_t index) const noexcept
1494 {
1495 return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
1496 }
1497
1498 nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) const noexcept
1499 {
1500 const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
1501
1502 if (libObjPtr) {
1503 return _EventClass {libObjPtr};
1504 }
1505
1506 return nonstd::nullopt;
1507 }
1508
1509 void packetContextFieldClass(const StructureFieldClass fc) const
1510 {
1511 static_assert(!std::is_const<LibObjT>::value,
1512 "Not available with `bt2::ConstStreamClass`.");
1513
1514 const auto status =
1515 bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
1516
1517 if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1518 throw MemoryError {};
1519 }
1520 }
1521
1522 nonstd::optional<_StructureFieldClass> packetContextFieldClass() const noexcept
1523 {
1524 const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
1525
1526 if (libObjPtr) {
1527 return _StructureFieldClass {libObjPtr};
1528 }
1529
1530 return nonstd::nullopt;
1531 }
1532
1533 void eventCommonContextFieldClass(const StructureFieldClass fc) const
1534 {
1535 static_assert(!std::is_const<LibObjT>::value,
1536 "Not available with `bt2::ConstStreamClass`.");
1537
1538 const auto status =
1539 bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
1540
1541 if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1542 throw MemoryError {};
1543 }
1544 }
1545
1546 nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
1547 {
1548 const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
1549
1550 if (libObjPtr) {
1551 return _StructureFieldClass {libObjPtr};
1552 }
1553
1554 return nonstd::nullopt;
1555 }
1556
1557 template <typename LibValT>
1558 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1559 {
1560 static_assert(!std::is_const<LibObjT>::value,
1561 "Not available with `bt2::ConstStreamClass`.");
1562
1563 bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1564 }
1565
1566 UserAttributes userAttributes() const noexcept
1567 {
1568 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1569 }
1570
1571 Shared shared() const noexcept
1572 {
1573 return Shared::createWithRef(*this);
1574 }
1575 };
1576
1577 using StreamClass = CommonStreamClass<bt_stream_class>;
1578 using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
1579
1580 namespace internal {
1581
1582 struct StreamClassTypeDescr
1583 {
1584 using Const = ConstStreamClass;
1585 using NonConst = StreamClass;
1586 };
1587
1588 template <>
1589 struct TypeDescr<StreamClass> : public StreamClassTypeDescr
1590 {
1591 };
1592
1593 template <>
1594 struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
1595 {
1596 };
1597
1598 } /* namespace internal */
1599
1600 template <typename LibObjT>
1601 typename CommonEventClass<LibObjT>::_StreamClass
1602 CommonEventClass<LibObjT>::streamClass() const noexcept
1603 {
1604 return _StreamClass {_Spec::streamClass(this->libObjPtr())};
1605 }
1606
1607 template <typename LibObjT>
1608 typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
1609 {
1610 return Class {_Spec::cls(this->libObjPtr())};
1611 }
1612
1613 namespace internal {
1614
1615 struct TraceClassRefFuncs final
1616 {
1617 static void get(const bt_trace_class * const libObjPtr) noexcept
1618 {
1619 bt_trace_class_get_ref(libObjPtr);
1620 }
1621
1622 static void put(const bt_trace_class * const libObjPtr) noexcept
1623 {
1624 bt_trace_class_put_ref(libObjPtr);
1625 }
1626 };
1627
1628 template <typename LibObjT>
1629 struct CommonTraceClassSpec;
1630
1631 /* Functions specific to mutable stream classes */
1632 template <>
1633 struct CommonTraceClassSpec<bt_trace_class> final
1634 {
1635 static bt_stream_class *streamClassByIndex(bt_trace_class * const libObjPtr,
1636 const std::uint64_t index) noexcept
1637 {
1638 return bt_trace_class_borrow_stream_class_by_index(libObjPtr, index);
1639 }
1640
1641 static bt_stream_class *streamClassById(bt_trace_class * const libObjPtr,
1642 const std::uint64_t id) noexcept
1643 {
1644 return bt_trace_class_borrow_stream_class_by_id(libObjPtr, id);
1645 }
1646
1647 static bt_value *userAttributes(bt_trace_class * const libObjPtr) noexcept
1648 {
1649 return bt_trace_class_borrow_user_attributes(libObjPtr);
1650 }
1651 };
1652
1653 /* Functions specific to constant stream classes */
1654 template <>
1655 struct CommonTraceClassSpec<const bt_trace_class> final
1656 {
1657 static const bt_stream_class *streamClassByIndex(const bt_trace_class * const libObjPtr,
1658 const std::uint64_t index) noexcept
1659 {
1660 return bt_trace_class_borrow_stream_class_by_index_const(libObjPtr, index);
1661 }
1662
1663 static const bt_stream_class *streamClassById(const bt_trace_class * const libObjPtr,
1664 const std::uint64_t id) noexcept
1665 {
1666 return bt_trace_class_borrow_stream_class_by_id_const(libObjPtr, id);
1667 }
1668
1669 static const bt_value *userAttributes(const bt_trace_class * const libObjPtr) noexcept
1670 {
1671 return bt_trace_class_borrow_user_attributes_const(libObjPtr);
1672 }
1673 };
1674
1675 } /* namespace internal */
1676
1677 template <typename LibObjT>
1678 class CommonTraceClass final : public BorrowedObject<LibObjT>
1679 {
1680 private:
1681 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1682 using typename BorrowedObject<LibObjT>::_LibObjPtr;
1683 using _Spec = internal::CommonTraceClassSpec<LibObjT>;
1684
1685 using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
1686 CommonStreamClass<const bt_stream_class>>;
1687
1688 public:
1689 using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
1690 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1691
1692 explicit CommonTraceClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1693 {
1694 }
1695
1696 template <typename OtherLibObjT>
1697 CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
1698 _ThisBorrowedObject {traceClass}
1699 {
1700 }
1701
1702 template <typename OtherLibObjT>
1703 CommonTraceClass operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
1704 {
1705 _ThisBorrowedObject::operator=(traceClass);
1706 return *this;
1707 }
1708
1709 CommonTraceClass<const bt_trace_class> asConst() const noexcept
1710 {
1711 return CommonTraceClass<const bt_trace_class> {*this};
1712 }
1713
1714 Trace::Shared instantiate() const
1715 {
1716 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1717
1718 const auto libObjPtr = bt_trace_create(this->libObjPtr());
1719
1720 internal::validateCreatedObjPtr(libObjPtr);
1721 return Trace::Shared::createWithoutRef(libObjPtr);
1722 }
1723
1724 StreamClass::Shared createStreamClass() const
1725 {
1726 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1727
1728 const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
1729
1730 internal::validateCreatedObjPtr(libObjPtr);
1731 return StreamClass::Shared::createWithoutRef(libObjPtr);
1732 }
1733
1734 StreamClass::Shared createStreamClass(const std::uint64_t id) const
1735 {
1736 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1737
1738 const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
1739
1740 internal::validateCreatedObjPtr(libObjPtr);
1741 return StreamClass::Shared::createWithoutRef(libObjPtr);
1742 }
1743
1744 FieldClass::Shared createBoolFieldClass() const
1745 {
1746 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1747
1748 const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
1749
1750 internal::validateCreatedObjPtr(libObjPtr);
1751 return FieldClass::Shared::createWithoutRef(libObjPtr);
1752 }
1753
1754 BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
1755 {
1756 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1757
1758 const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
1759
1760 internal::validateCreatedObjPtr(libObjPtr);
1761 return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1762 }
1763
1764 IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
1765 {
1766 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1767
1768 const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
1769
1770 internal::validateCreatedObjPtr(libObjPtr);
1771 return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1772 }
1773
1774 IntegerFieldClass::Shared createSignedIntegerFieldClass() const
1775 {
1776 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1777
1778 const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
1779
1780 internal::validateCreatedObjPtr(libObjPtr);
1781 return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1782 }
1783
1784 UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
1785 {
1786 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1787
1788 const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
1789
1790 internal::validateCreatedObjPtr(libObjPtr);
1791 return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1792 }
1793
1794 SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
1795 {
1796 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1797
1798 const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
1799
1800 internal::validateCreatedObjPtr(libObjPtr);
1801 return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1802 }
1803
1804 FieldClass::Shared createSinglePrecisionRealFieldClass() const
1805 {
1806 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1807
1808 const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
1809
1810 internal::validateCreatedObjPtr(libObjPtr);
1811 return FieldClass::Shared::createWithoutRef(libObjPtr);
1812 }
1813
1814 FieldClass::Shared createDoublePrecisionRealFieldClass() const
1815 {
1816 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1817
1818 const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
1819
1820 internal::validateCreatedObjPtr(libObjPtr);
1821 return FieldClass::Shared::createWithoutRef(libObjPtr);
1822 }
1823
1824 FieldClass::Shared createStringFieldClass() const
1825 {
1826 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1827
1828 const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
1829
1830 internal::validateCreatedObjPtr(libObjPtr);
1831 return FieldClass::Shared::createWithoutRef(libObjPtr);
1832 }
1833
1834 StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
1835 const std::uint64_t length) const
1836 {
1837 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1838
1839 const auto libObjPtr = bt_field_class_array_static_create(
1840 this->libObjPtr(), elementFieldClass.libObjPtr(), length);
1841
1842 internal::validateCreatedObjPtr(libObjPtr);
1843 return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1844 }
1845
1846 ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
1847 {
1848 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1849
1850 const auto libObjPtr = bt_field_class_array_dynamic_create(
1851 this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
1852
1853 internal::validateCreatedObjPtr(libObjPtr);
1854 return ArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1855 }
1856
1857 DynamicArrayWithLengthFieldClass::Shared
1858 createDynamicArrayFieldClass(const FieldClass elementFieldClass,
1859 const IntegerFieldClass lengthFieldClass) const
1860 {
1861 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1862
1863 const auto libObjPtr = bt_field_class_array_dynamic_create(
1864 this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
1865
1866 internal::validateCreatedObjPtr(libObjPtr);
1867 return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
1868 }
1869
1870 StructureFieldClass::Shared createStructureFieldClass() const
1871 {
1872 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1873
1874 const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
1875
1876 internal::validateCreatedObjPtr(libObjPtr);
1877 return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
1878 }
1879
1880 OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
1881 {
1882 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1883
1884 const auto libObjPtr = bt_field_class_option_without_selector_create(
1885 this->libObjPtr(), optionalFieldClass.libObjPtr());
1886
1887 internal::validateCreatedObjPtr(libObjPtr);
1888 return OptionFieldClass::Shared::createWithoutRef(libObjPtr);
1889 }
1890
1891 OptionWithBoolSelectorFieldClass::Shared
1892 createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
1893 const FieldClass selectorFieldClass) const
1894 {
1895 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1896
1897 const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
1898 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
1899
1900 internal::validateCreatedObjPtr(libObjPtr);
1901 return OptionWithBoolSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1902 }
1903
1904 OptionWithUnsignedIntegerSelectorFieldClass::Shared
1905 createOptionWithUnsignedIntegerSelectorFieldClass(
1906 const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
1907 const ConstUnsignedIntegerRangeSet ranges) const
1908 {
1909 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1910
1911 const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
1912 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1913 ranges.libObjPtr());
1914
1915 internal::validateCreatedObjPtr(libObjPtr);
1916 return OptionWithUnsignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1917 }
1918
1919 OptionWithSignedIntegerSelectorFieldClass::Shared
1920 createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
1921 const IntegerFieldClass selectorFieldClass,
1922 const ConstSignedIntegerRangeSet ranges) const
1923 {
1924 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1925
1926 const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
1927 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1928 ranges.libObjPtr());
1929
1930 internal::validateCreatedObjPtr(libObjPtr);
1931 return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1932 }
1933
1934 VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
1935 {
1936 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1937
1938 const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
1939
1940 internal::validateCreatedObjPtr(libObjPtr);
1941 return VariantWithoutSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1942 }
1943
1944 VariantWithUnsignedIntegerSelectorFieldClass::Shared
1945 createVariantWithUnsignedIntegerSelectorFieldClass(
1946 const IntegerFieldClass selectorFieldClass) const
1947 {
1948 return this->_createVariantWithIntegerSelectorFieldClass<
1949 VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
1950 }
1951
1952 VariantWithSignedIntegerSelectorFieldClass::Shared
1953 createVariantWithSignedIntegerSelectorFieldClass(
1954 const IntegerFieldClass selectorFieldClass) const
1955 {
1956 return this->_createVariantWithIntegerSelectorFieldClass<
1957 VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
1958 }
1959
1960 void assignsAutomaticStreamClassId(const bool val) const noexcept
1961 {
1962 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1963
1964 bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
1965 static_cast<bt_bool>(val));
1966 }
1967
1968 bool assignsAutomaticStreamClassId() const noexcept
1969 {
1970 return static_cast<bool>(
1971 bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
1972 }
1973
1974 std::uint64_t length() const noexcept
1975 {
1976 return bt_trace_class_get_stream_class_count(this->libObjPtr());
1977 }
1978
1979 _StreamClass operator[](const std::uint64_t index) const noexcept
1980 {
1981 return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
1982 }
1983
1984 nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
1985 {
1986 const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
1987
1988 if (libObjPtr) {
1989 return _StreamClass {libObjPtr};
1990 }
1991
1992 return nonstd::nullopt;
1993 }
1994
1995 template <typename LibValT>
1996 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1997 {
1998 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1999
2000 bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
2001 }
2002
2003 UserAttributes userAttributes() const noexcept
2004 {
2005 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
2006 }
2007
2008 Shared shared() const noexcept
2009 {
2010 return Shared::createWithRef(*this);
2011 }
2012
2013 private:
2014 template <typename ObjT>
2015 typename ObjT::Shared
2016 _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
2017 {
2018 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
2019
2020 const auto libObjPtr =
2021 bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
2022
2023 internal::validateCreatedObjPtr(libObjPtr);
2024 return ObjT::Shared::createWithoutRef(libObjPtr);
2025 }
2026 };
2027
2028 using TraceClass = CommonTraceClass<bt_trace_class>;
2029 using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
2030
2031 namespace internal {
2032
2033 struct TraceClassTypeDescr
2034 {
2035 using Const = ConstTraceClass;
2036 using NonConst = TraceClass;
2037 };
2038
2039 template <>
2040 struct TypeDescr<TraceClass> : public TraceClassTypeDescr
2041 {
2042 };
2043
2044 template <>
2045 struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
2046 {
2047 };
2048
2049 } /* namespace internal */
2050
2051 template <typename LibObjT>
2052 typename CommonStreamClass<LibObjT>::_TraceClass
2053 CommonStreamClass<LibObjT>::traceClass() const noexcept
2054 {
2055 return _TraceClass {_Spec::traceClass(this->libObjPtr())};
2056 }
2057
2058 template <typename LibObjT>
2059 typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
2060 {
2061 return Class {_Spec::cls(this->libObjPtr())};
2062 }
2063
2064 } /* namespace bt2 */
2065
2066 #endif /* BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP */
This page took 0.070012 seconds and 3 git commands to generate.