2 * Copyright (c) 2020-2021 Philippe Proulx <pproulx@efficios.com>
4 * SPDX-License-Identifier: MIT
7 #ifndef BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
8 #define BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
11 #include <type_traits>
13 #include <babeltrace2/babeltrace.h>
15 #include "cpp-common/bt2s/optional.hpp"
17 #include "borrowed-object.hpp"
18 #include "clock-class.hpp"
19 #include "field-class.hpp"
21 #include "internal/utils.hpp"
22 #include "shared-object.hpp"
27 template <typename LibObjT>
30 template <typename LibObjT>
33 template <typename LibObjT>
36 template <typename LibObjT>
39 template <typename LibObjT>
40 class CommonEventClass;
42 template <typename LibObjT>
43 class CommonStreamClass;
45 template <typename LibObjT>
46 class CommonTraceClass;
50 template <typename LibObjT>
51 struct CommonEventSpec;
53 /* Functions specific to mutable events */
55 struct CommonEventSpec<bt_event> final
57 static bt_event_class *cls(bt_event * const libObjPtr) noexcept
59 return bt_event_borrow_class(libObjPtr);
62 static bt_stream *stream(bt_event * const libObjPtr) noexcept
64 return bt_event_borrow_stream(libObjPtr);
67 static bt_packet *packet(bt_event * const libObjPtr) noexcept
69 return bt_event_borrow_packet(libObjPtr);
72 static bt_field *payloadField(bt_event * const libObjPtr) noexcept
74 return bt_event_borrow_payload_field(libObjPtr);
77 static bt_field *specificContextField(bt_event * const libObjPtr) noexcept
79 return bt_event_borrow_specific_context_field(libObjPtr);
82 static bt_field *commonContextField(bt_event * const libObjPtr) noexcept
84 return bt_event_borrow_common_context_field(libObjPtr);
88 /* Functions specific to constant events */
90 struct CommonEventSpec<const bt_event> final
92 static const bt_event_class *cls(const bt_event * const libObjPtr) noexcept
94 return bt_event_borrow_class_const(libObjPtr);
97 static const bt_stream *stream(const bt_event * const libObjPtr) noexcept
99 return bt_event_borrow_stream_const(libObjPtr);
102 static const bt_packet *packet(const bt_event * const libObjPtr) noexcept
104 return bt_event_borrow_packet_const(libObjPtr);
107 static const bt_field *payloadField(const bt_event * const libObjPtr) noexcept
109 return bt_event_borrow_payload_field_const(libObjPtr);
112 static const bt_field *specificContextField(const bt_event * const libObjPtr) noexcept
114 return bt_event_borrow_specific_context_field_const(libObjPtr);
117 static const bt_field *commonContextField(const bt_event * const libObjPtr) noexcept
119 return bt_event_borrow_common_context_field_const(libObjPtr);
123 template <typename LibObjT>
124 using DepStructField = DepType<LibObjT, StructureField, ConstStructureField>;
126 } /* namespace internal */
128 template <typename LibObjT>
129 class CommonEvent final : public BorrowedObject<LibObjT>
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>;
140 using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
141 CommonEventClass<const bt_event_class>>;
143 explicit CommonEvent(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
147 template <typename OtherLibObjT>
148 CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
152 template <typename OtherLibObjT>
153 CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
155 _ThisBorrowedObject::operator=(event);
159 CommonEvent<const bt_event> asConst() const noexcept
161 return CommonEvent<const bt_event> {*this};
164 Class cls() const noexcept;
165 _Stream stream() const noexcept;
166 bt2s::optional<_Packet> packet() const noexcept;
168 bt2s::optional<_StructureField> payloadField() const noexcept
170 const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
173 return _StructureField {libObjPtr};
176 return bt2s::nullopt;
179 bt2s::optional<_StructureField> specificContextField() const noexcept
181 const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
184 return _StructureField {libObjPtr};
187 return bt2s::nullopt;
190 bt2s::optional<_StructureField> commonContextField() const noexcept
192 const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
195 return _StructureField {libObjPtr};
198 return bt2s::nullopt;
202 using Event = CommonEvent<bt_event>;
203 using ConstEvent = CommonEvent<const bt_event>;
207 struct EventTypeDescr
209 using Const = ConstEvent;
210 using NonConst = Event;
214 struct TypeDescr<Event> : public EventTypeDescr
219 struct TypeDescr<ConstEvent> : public EventTypeDescr
223 struct PacketRefFuncs final
225 static void get(const bt_packet * const libObjPtr) noexcept
227 bt_packet_get_ref(libObjPtr);
230 static void put(const bt_packet * const libObjPtr) noexcept
232 bt_packet_put_ref(libObjPtr);
236 template <typename LibObjT>
237 struct CommonPacketSpec;
239 /* Functions specific to mutable packets */
241 struct CommonPacketSpec<bt_packet> final
243 static bt_stream *stream(bt_packet * const libObjPtr) noexcept
245 return bt_packet_borrow_stream(libObjPtr);
248 static bt_field *contextField(bt_packet * const libObjPtr) noexcept
250 return bt_packet_borrow_context_field(libObjPtr);
254 /* Functions specific to constant packets */
256 struct CommonPacketSpec<const bt_packet> final
258 static const bt_stream *stream(const bt_packet * const libObjPtr) noexcept
260 return bt_packet_borrow_stream_const(libObjPtr);
263 static const bt_field *contextField(const bt_packet * const libObjPtr) noexcept
265 return bt_packet_borrow_context_field_const(libObjPtr);
269 } /* namespace internal */
271 template <typename LibObjT>
272 class CommonPacket final : public BorrowedObject<LibObjT>
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>;
282 using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
284 explicit CommonPacket(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
288 template <typename OtherLibObjT>
289 CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
293 template <typename OtherLibObjT>
294 CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
296 _ThisBorrowedObject::operator=(packet);
300 CommonPacket<const bt_packet> asConst() const noexcept
302 return CommonPacket<const bt_packet> {*this};
305 _Stream stream() const noexcept;
307 bt2s::optional<_StructureField> contextField() const noexcept
309 const auto libObjPtr = _Spec::contextField(this->libObjPtr());
312 return _StructureField {libObjPtr};
315 return bt2s::nullopt;
318 Shared shared() const noexcept
320 return Shared::createWithRef(*this);
324 using Packet = CommonPacket<bt_packet>;
325 using ConstPacket = CommonPacket<const bt_packet>;
329 struct PacketTypeDescr
331 using Const = ConstPacket;
332 using NonConst = Packet;
336 struct TypeDescr<Packet> : public PacketTypeDescr
341 struct TypeDescr<ConstPacket> : public PacketTypeDescr
345 } /* namespace internal */
347 template <typename LibObjT>
348 bt2s::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() const noexcept
350 const auto libObjPtr = _Spec::packet(this->libObjPtr());
353 return _Packet {libObjPtr};
356 return bt2s::nullopt;
361 struct StreamRefFuncs final
363 static void get(const bt_stream * const libObjPtr) noexcept
365 bt_stream_get_ref(libObjPtr);
368 static void put(const bt_stream * const libObjPtr) noexcept
370 bt_stream_put_ref(libObjPtr);
374 template <typename LibObjT>
375 struct CommonStreamSpec;
377 /* Functions specific to mutable streams */
379 struct CommonStreamSpec<bt_stream> final
381 static bt_stream_class *cls(bt_stream * const libObjPtr) noexcept
383 return bt_stream_borrow_class(libObjPtr);
386 static bt_trace *trace(bt_stream * const libObjPtr) noexcept
388 return bt_stream_borrow_trace(libObjPtr);
391 static bt_value *userAttributes(bt_stream * const libObjPtr) noexcept
393 return bt_stream_borrow_user_attributes(libObjPtr);
397 /* Functions specific to constant streams */
399 struct CommonStreamSpec<const bt_stream> final
401 static const bt_stream_class *cls(const bt_stream * const libObjPtr) noexcept
403 return bt_stream_borrow_class_const(libObjPtr);
406 static const bt_trace *trace(const bt_stream * const libObjPtr) noexcept
408 return bt_stream_borrow_trace_const(libObjPtr);
411 static const bt_value *userAttributes(const bt_stream * const libObjPtr) noexcept
413 return bt_stream_borrow_user_attributes_const(libObjPtr);
417 } /* namespace internal */
419 template <typename LibObjT>
420 class CommonStream final : public BorrowedObject<LibObjT>
423 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
424 using typename BorrowedObject<LibObjT>::_LibObjPtr;
425 using _Spec = internal::CommonStreamSpec<LibObjT>;
426 using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
429 using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
430 using UserAttributes = internal::DepUserAttrs<LibObjT>;
432 using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
433 CommonStreamClass<const bt_stream_class>>;
435 explicit CommonStream(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
439 template <typename OtherLibObjT>
440 CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObject {stream}
444 template <typename OtherLibObjT>
445 CommonStream operator=(const CommonStream<OtherLibObjT> stream) noexcept
447 _ThisBorrowedObject::operator=(stream);
451 CommonStream<const bt_stream> asConst() const noexcept
453 return CommonStream<const bt_stream> {*this};
456 Packet::Shared createPacket() const
458 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
460 const auto libObjPtr = bt_packet_create(this->libObjPtr());
462 internal::validateCreatedObjPtr(libObjPtr);
463 return Packet::Shared::createWithoutRef(libObjPtr);
466 Class cls() const noexcept;
467 _Trace trace() const noexcept;
469 std::uint64_t id() const noexcept
471 return bt_stream_get_id(this->libObjPtr());
474 void name(const char * const name) const
476 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
478 const auto status = bt_stream_set_name(this->libObjPtr(), name);
480 if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
481 throw MemoryError {};
485 void name(const std::string& name) const
487 this->name(name.data());
490 const char *name() const noexcept
492 return bt_stream_get_name(this->libObjPtr());
495 template <typename LibValT>
496 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
498 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
500 bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
503 UserAttributes userAttributes() const noexcept
505 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
508 Shared shared() const noexcept
510 return Shared::createWithRef(*this);
514 using Stream = CommonStream<bt_stream>;
515 using ConstStream = CommonStream<const bt_stream>;
519 struct StreamTypeDescr
521 using Const = ConstStream;
522 using NonConst = Stream;
526 struct TypeDescr<Stream> : public StreamTypeDescr
531 struct TypeDescr<ConstStream> : public StreamTypeDescr
535 } /* namespace internal */
537 template <typename LibObjT>
538 typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
540 return _Stream {_Spec::stream(this->libObjPtr())};
543 template <typename LibObjT>
544 typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
546 return _Stream {_Spec::stream(this->libObjPtr())};
551 struct TraceRefFuncs final
553 static void get(const bt_trace * const libObjPtr) noexcept
555 bt_trace_get_ref(libObjPtr);
558 static void put(const bt_trace * const libObjPtr) noexcept
560 bt_trace_put_ref(libObjPtr);
564 template <typename LibObjT>
565 struct CommonTraceSpec;
567 /* Functions specific to mutable traces */
569 struct CommonTraceSpec<bt_trace> final
571 static bt_trace_class *cls(bt_trace * const libObjPtr) noexcept
573 return bt_trace_borrow_class(libObjPtr);
576 static bt_stream *streamByIndex(bt_trace * const libObjPtr, const std::uint64_t index) noexcept
578 return bt_trace_borrow_stream_by_index(libObjPtr, index);
581 static bt_stream *streamById(bt_trace * const libObjPtr, const std::uint64_t id) noexcept
583 return bt_trace_borrow_stream_by_id(libObjPtr, id);
586 static bt_value *userAttributes(bt_trace * const libObjPtr) noexcept
588 return bt_trace_borrow_user_attributes(libObjPtr);
592 /* Functions specific to constant traces */
594 struct CommonTraceSpec<const bt_trace> final
596 static const bt_trace_class *cls(const bt_trace * const libObjPtr) noexcept
598 return bt_trace_borrow_class_const(libObjPtr);
601 static const bt_stream *streamByIndex(const bt_trace * const libObjPtr,
602 const std::uint64_t index) noexcept
604 return bt_trace_borrow_stream_by_index_const(libObjPtr, index);
607 static const bt_stream *streamById(const bt_trace * const libObjPtr,
608 const std::uint64_t id) noexcept
610 return bt_trace_borrow_stream_by_id_const(libObjPtr, id);
613 static const bt_value *userAttributes(const bt_trace * const libObjPtr) noexcept
615 return bt_trace_borrow_user_attributes_const(libObjPtr);
619 } /* namespace internal */
621 template <typename LibObjT>
622 class CommonTrace final : public BorrowedObject<LibObjT>
625 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
626 using typename BorrowedObject<LibObjT>::_LibObjPtr;
627 using _Spec = internal::CommonTraceSpec<LibObjT>;
628 using _Stream = internal::DepStream<LibObjT>;
631 using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
632 using UserAttributes = internal::DepUserAttrs<LibObjT>;
634 using Class = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
635 CommonTraceClass<const bt_trace_class>>;
637 struct ConstEnvironmentEntry
643 explicit CommonTrace(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
647 template <typename OtherLibObjT>
648 CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObject {trace}
652 template <typename OtherLibObjT>
653 CommonTrace operator=(const CommonTrace<OtherLibObjT> trace) noexcept
655 _ThisBorrowedObject::operator=(trace);
659 CommonTrace<const bt_trace> asConst() const noexcept
661 return CommonTrace<const bt_trace> {*this};
664 Class cls() const noexcept;
666 void name(const char * const name) const
668 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
670 const auto status = bt_trace_set_name(this->libObjPtr(), name);
672 if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
673 throw MemoryError {};
677 void name(const std::string& name) const
679 this->name(name.data());
682 const char *name() const noexcept
684 return bt_trace_get_name(this->libObjPtr());
687 void uuid(const bt2c::UuidView& uuid) const noexcept
689 bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
692 bt2s::optional<bt2c::UuidView> uuid() const noexcept
694 const auto uuid = bt_trace_get_uuid(this->libObjPtr());
697 return bt2c::UuidView {uuid};
700 return bt2s::nullopt;
703 std::uint64_t length() const noexcept
705 return bt_trace_get_stream_count(this->libObjPtr());
708 _Stream operator[](const std::uint64_t index) const noexcept
710 return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
713 bt2s::optional<_Stream> streamById(const std::uint64_t id) const noexcept
715 const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
718 return _Stream {libObjPtr};
721 return bt2s::nullopt;
724 void environmentEntry(const char * const name, const std::int64_t val) const
726 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
728 const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
730 if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
731 throw MemoryError {};
735 void environmentEntry(const std::string& name, const std::int64_t val) const
737 this->environmentEntry(name.data(), val);
740 void environmentEntry(const char * const name, const char * const val) const
742 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
744 const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
746 if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
747 throw MemoryError {};
751 void environmentEntry(const std::string& name, const char * const val) const
753 this->environmentEntry(name.data(), val);
756 void environmentEntry(const char * const name, const std::string& val) const
758 this->environmentEntry(name, val.data());
761 void environmentEntry(const std::string& name, const std::string& val) const
763 this->environmentEntry(name.data(), val.data());
766 std::uint64_t environmentSize() const noexcept
768 return bt_trace_get_environment_entry_count(this->libObjPtr());
771 ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
774 const bt_value *libObjPtr;
776 bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
778 return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
781 bt2s::optional<ConstValue> environmentEntry(const char * const name) const noexcept
783 const auto libObjPtr =
784 bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
787 return ConstValue {libObjPtr};
790 return bt2s::nullopt;
793 bt2s::optional<ConstValue> environmentEntry(const std::string& name) const noexcept
795 return this->environmentEntry(name.data());
798 template <typename LibValT>
799 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
801 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
803 bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
806 UserAttributes userAttributes() const noexcept
808 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
811 Shared shared() const noexcept
813 return Shared::createWithRef(*this);
817 using Trace = CommonTrace<bt_trace>;
818 using ConstTrace = CommonTrace<const bt_trace>;
822 struct TraceTypeDescr
824 using Const = ConstTrace;
825 using NonConst = Trace;
829 struct TypeDescr<Trace> : public TraceTypeDescr
834 struct TypeDescr<ConstTrace> : public TraceTypeDescr
838 } /* namespace internal */
840 template <typename LibObjT>
841 typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
843 return _Trace {_Spec::trace(this->libObjPtr())};
848 struct EventClassRefFuncs final
850 static void get(const bt_event_class * const libObjPtr) noexcept
852 bt_event_class_get_ref(libObjPtr);
855 static void put(const bt_event_class * const libObjPtr) noexcept
857 bt_event_class_put_ref(libObjPtr);
861 template <typename LibObjT>
862 struct CommonEventClassSpec;
864 /* Functions specific to mutable event classes */
866 struct CommonEventClassSpec<bt_event_class> final
868 static bt_stream_class *streamClass(bt_event_class * const libObjPtr) noexcept
870 return bt_event_class_borrow_stream_class(libObjPtr);
873 static bt_field_class *payloadFieldClass(bt_event_class * const libObjPtr) noexcept
875 return bt_event_class_borrow_payload_field_class(libObjPtr);
878 static bt_field_class *specificContextFieldClass(bt_event_class * const libObjPtr) noexcept
880 return bt_event_class_borrow_specific_context_field_class(libObjPtr);
883 static bt_value *userAttributes(bt_event_class * const libObjPtr) noexcept
885 return bt_event_class_borrow_user_attributes(libObjPtr);
889 /* Functions specific to constant event classes */
891 struct CommonEventClassSpec<const bt_event_class> final
893 static const bt_stream_class *streamClass(const bt_event_class * const libObjPtr) noexcept
895 return bt_event_class_borrow_stream_class_const(libObjPtr);
898 static const bt_field_class *payloadFieldClass(const bt_event_class * const libObjPtr) noexcept
900 return bt_event_class_borrow_payload_field_class_const(libObjPtr);
903 static const bt_field_class *
904 specificContextFieldClass(const bt_event_class * const libObjPtr) noexcept
906 return bt_event_class_borrow_specific_context_field_class_const(libObjPtr);
909 static const bt_value *userAttributes(const bt_event_class * const libObjPtr) noexcept
911 return bt_event_class_borrow_user_attributes_const(libObjPtr);
915 template <typename LibObjT>
916 using DepStructFc = DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
918 } /* namespace internal */
920 template <typename LibObjT>
921 class CommonEventClass final : public BorrowedObject<LibObjT>
924 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
925 using typename BorrowedObject<LibObjT>::_LibObjPtr;
926 using _Spec = internal::CommonEventClassSpec<LibObjT>;
927 using _StructureFieldClass = internal::DepStructFc<LibObjT>;
929 using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
930 CommonStreamClass<const bt_stream_class>>;
933 using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
934 using UserAttributes = internal::DepUserAttrs<LibObjT>;
938 EMERGENCY = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
939 ALERT = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
940 CRITICAL = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
941 ERR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
942 WARNING = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
943 NOTICE = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
944 INFO = BT_EVENT_CLASS_LOG_LEVEL_INFO,
945 DEBUG_SYSTEM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
946 DEBUG_PROGRAM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
947 DEBUG_PROC = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
948 DEBUG_MODULE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
949 DEBUG_UNIT = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
950 DEBUG_FUNCTION = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
951 DEBUG_LINE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
952 DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
955 explicit CommonEventClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
959 template <typename OtherLibObjT>
960 CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
961 _ThisBorrowedObject {eventClass}
965 template <typename OtherLibObjT>
966 CommonEventClass operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
968 _ThisBorrowedObject::operator=(eventClass);
972 CommonEventClass<const bt_event_class> asConst() const noexcept
974 return CommonEventClass<const bt_event_class> {*this};
977 _StreamClass streamClass() const noexcept;
979 std::uint64_t id() const noexcept
981 return bt_event_class_get_id(this->libObjPtr());
984 void name(const char * const name) const
986 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
988 const auto status = bt_event_class_set_name(this->libObjPtr(), name);
990 if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
991 throw MemoryError {};
995 void name(const std::string& name) const
997 this->name(name.data());
1000 const char *name() const noexcept
1002 return bt_event_class_get_name(this->libObjPtr());
1005 void logLevel(const LogLevel logLevel) const noexcept
1007 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1009 bt_event_class_set_log_level(this->libObjPtr(),
1010 static_cast<bt_event_class_log_level>(logLevel));
1013 bt2s::optional<LogLevel> logLevel() const noexcept
1015 bt_event_class_log_level libLogLevel;
1016 const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
1018 if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
1019 return static_cast<LogLevel>(libLogLevel);
1022 return bt2s::nullopt;
1025 void emfUri(const char * const emfUri) const
1027 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1029 const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
1031 if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
1032 throw MemoryError {};
1036 void emfUri(const std::string& emfUri) const
1038 this->emfUri(emfUri.data());
1041 const char *emfUri() const noexcept
1043 return bt_event_class_get_emf_uri(this->libObjPtr());
1046 void payloadFieldClass(const StructureFieldClass fc) const
1048 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1051 bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
1053 if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1054 throw MemoryError {};
1058 bt2s::optional<_StructureFieldClass> payloadFieldClass() const noexcept
1060 const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
1063 return _StructureFieldClass {libObjPtr};
1066 return bt2s::nullopt;
1069 void specificContextFieldClass(const StructureFieldClass fc) const
1071 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1074 bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
1076 if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1077 throw MemoryError {};
1081 bt2s::optional<_StructureFieldClass> specificContextFieldClass() const noexcept
1083 const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
1086 return _StructureFieldClass {libObjPtr};
1089 return bt2s::nullopt;
1092 template <typename LibValT>
1093 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1095 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1097 bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1100 UserAttributes userAttributes() const noexcept
1102 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1105 Shared shared() const noexcept
1107 return Shared::createWithRef(*this);
1111 using EventClass = CommonEventClass<bt_event_class>;
1112 using ConstEventClass = CommonEventClass<const bt_event_class>;
1114 namespace internal {
1116 struct EventClassTypeDescr
1118 using Const = ConstEventClass;
1119 using NonConst = EventClass;
1123 struct TypeDescr<EventClass> : public EventClassTypeDescr
1128 struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
1132 } /* namespace internal */
1134 template <typename LibObjT>
1135 typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
1137 return Class {_Spec::cls(this->libObjPtr())};
1140 namespace internal {
1142 struct StreamClassRefFuncs final
1144 static void get(const bt_stream_class * const libObjPtr) noexcept
1146 bt_stream_class_get_ref(libObjPtr);
1149 static void put(const bt_stream_class * const libObjPtr) noexcept
1151 bt_stream_class_put_ref(libObjPtr);
1155 template <typename LibObjT>
1156 struct CommonStreamClassSpec;
1158 /* Functions specific to mutable stream classes */
1160 struct CommonStreamClassSpec<bt_stream_class> final
1162 static bt_trace_class *traceClass(bt_stream_class * const libObjPtr) noexcept
1164 return bt_stream_class_borrow_trace_class(libObjPtr);
1167 static bt_event_class *eventClassByIndex(bt_stream_class * const libObjPtr,
1168 const std::uint64_t index) noexcept
1170 return bt_stream_class_borrow_event_class_by_index(libObjPtr, index);
1173 static bt_event_class *eventClassById(bt_stream_class * const libObjPtr,
1174 const std::uint64_t id) noexcept
1176 return bt_stream_class_borrow_event_class_by_id(libObjPtr, id);
1179 static bt_clock_class *defaultClockClass(bt_stream_class * const libObjPtr) noexcept
1181 return bt_stream_class_borrow_default_clock_class(libObjPtr);
1184 static bt_field_class *packetContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1186 return bt_stream_class_borrow_packet_context_field_class(libObjPtr);
1189 static bt_field_class *eventCommonContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1191 return bt_stream_class_borrow_event_common_context_field_class(libObjPtr);
1194 static bt_value *userAttributes(bt_stream_class * const libObjPtr) noexcept
1196 return bt_stream_class_borrow_user_attributes(libObjPtr);
1200 /* Functions specific to constant stream classes */
1202 struct CommonStreamClassSpec<const bt_stream_class> final
1204 static const bt_trace_class *traceClass(const bt_stream_class * const libObjPtr) noexcept
1206 return bt_stream_class_borrow_trace_class_const(libObjPtr);
1209 static const bt_event_class *eventClassByIndex(const bt_stream_class * const libObjPtr,
1210 const std::uint64_t index) noexcept
1212 return bt_stream_class_borrow_event_class_by_index_const(libObjPtr, index);
1215 static const bt_event_class *eventClassById(const bt_stream_class * const libObjPtr,
1216 const std::uint64_t id) noexcept
1218 return bt_stream_class_borrow_event_class_by_id_const(libObjPtr, id);
1221 static const bt_clock_class *defaultClockClass(const bt_stream_class * const libObjPtr) noexcept
1223 return bt_stream_class_borrow_default_clock_class_const(libObjPtr);
1226 static const bt_field_class *
1227 packetContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1229 return bt_stream_class_borrow_packet_context_field_class_const(libObjPtr);
1232 static const bt_field_class *
1233 eventCommonContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1235 return bt_stream_class_borrow_event_common_context_field_class_const(libObjPtr);
1238 static const bt_value *userAttributes(const bt_stream_class * const libObjPtr) noexcept
1240 return bt_stream_class_borrow_user_attributes_const(libObjPtr);
1244 } /* namespace internal */
1246 template <typename LibObjT>
1247 class CommonStreamClass final : public BorrowedObject<LibObjT>
1250 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1251 using typename BorrowedObject<LibObjT>::_LibObjPtr;
1252 using _Spec = internal::CommonStreamClassSpec<LibObjT>;
1253 using _StructureFieldClass = internal::DepStructFc<LibObjT>;
1255 using _TraceClass = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
1256 CommonTraceClass<const bt_trace_class>>;
1258 using _EventClass = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
1259 CommonEventClass<const bt_event_class>>;
1261 using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
1264 using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
1265 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1267 explicit CommonStreamClass(const _LibObjPtr libObjPtr) noexcept :
1268 _ThisBorrowedObject {libObjPtr}
1272 template <typename OtherLibObjT>
1273 CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
1274 _ThisBorrowedObject {streamClass}
1278 template <typename OtherLibObjT>
1279 CommonStreamClass operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
1281 _ThisBorrowedObject::operator=(streamClass);
1285 CommonStreamClass<const bt_stream_class> asConst() const noexcept
1287 return CommonStreamClass<const bt_stream_class> {*this};
1290 Stream::Shared instantiate(const Trace trace) const
1292 static_assert(!std::is_const<LibObjT>::value,
1293 "Not available with `bt2::ConstStreamClass`.");
1295 const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
1297 internal::validateCreatedObjPtr(libObjPtr);
1298 return Stream::Shared::createWithoutRef(libObjPtr);
1301 Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
1303 static_assert(!std::is_const<LibObjT>::value,
1304 "Not available with `bt2::ConstStreamClass`.");
1306 const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
1308 internal::validateCreatedObjPtr(libObjPtr);
1309 return Stream::Shared::createWithoutRef(libObjPtr);
1312 EventClass::Shared createEventClass() const
1314 static_assert(!std::is_const<LibObjT>::value,
1315 "Not available with `bt2::ConstStreamClass`.");
1317 const auto libObjPtr = bt_event_class_create(this->libObjPtr());
1319 internal::validateCreatedObjPtr(libObjPtr);
1320 return EventClass::Shared::createWithoutRef(libObjPtr);
1323 EventClass::Shared createEventClass(const std::uint64_t id) const
1325 static_assert(!std::is_const<LibObjT>::value,
1326 "Not available with `bt2::ConstStreamClass`.");
1328 const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
1330 internal::validateCreatedObjPtr(libObjPtr);
1331 return EventClass::Shared::createWithoutRef(libObjPtr);
1334 _TraceClass traceClass() const noexcept;
1336 std::uint64_t id() const noexcept
1338 return bt_stream_class_get_id(this->libObjPtr());
1341 void name(const char * const name) const
1343 static_assert(!std::is_const<LibObjT>::value,
1344 "Not available with `bt2::ConstStreamClass`.");
1346 const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
1348 if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
1349 throw MemoryError {};
1353 void name(const std::string& name) const
1355 this->name(name.data());
1358 const char *name() const noexcept
1360 return bt_stream_class_get_name(this->libObjPtr());
1363 void assignsAutomaticEventClassId(const bool val) const noexcept
1365 static_assert(!std::is_const<LibObjT>::value,
1366 "Not available with `bt2::ConstStreamClass`.");
1368 bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
1369 static_cast<bt_bool>(val));
1372 bool assignsAutomaticEventClassId() const noexcept
1374 return static_cast<bool>(
1375 bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
1378 void assignsAutomaticStreamId(const bool val) const noexcept
1380 static_assert(!std::is_const<LibObjT>::value,
1381 "Not available with `bt2::ConstStreamClass`.");
1383 bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
1384 static_cast<bt_bool>(val));
1387 bool assignsAutomaticStreamId() const noexcept
1389 return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
1392 void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
1393 const bool withEndDefaultClkSnapshot) const noexcept
1395 static_assert(!std::is_const<LibObjT>::value,
1396 "Not available with `bt2::ConstStreamClass`.");
1398 bt_stream_class_set_supports_packets(this->libObjPtr(),
1399 static_cast<bt_bool>(supportsPackets),
1400 static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
1401 static_cast<bt_bool>(withEndDefaultClkSnapshot));
1404 bool supportsPackets() const noexcept
1406 return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
1409 bool packetsHaveBeginningClockSnapshot() const noexcept
1411 return static_cast<bool>(
1412 bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
1415 bool packetsHaveEndClockSnapshot() const noexcept
1417 return static_cast<bool>(
1418 bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
1421 void supportsDiscardedEvents(const bool supportsDiscardedEvents,
1422 const bool withDefaultClkSnapshots) const noexcept
1424 static_assert(!std::is_const<LibObjT>::value,
1425 "Not available with `bt2::ConstStreamClass`.");
1427 bt_stream_class_set_supports_discarded_events(
1428 this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedEvents),
1429 static_cast<bt_bool>(withDefaultClkSnapshots));
1432 bool supportsDiscardedEvents() const noexcept
1434 return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
1437 bool discardedEventsHaveDefaultClockSnapshots() const noexcept
1439 return static_cast<bool>(
1440 bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
1443 void supportsDiscardedPackets(const bool supportsDiscardedPackets,
1444 const bool withDefaultClkSnapshots) const noexcept
1446 static_assert(!std::is_const<LibObjT>::value,
1447 "Not available with `bt2::ConstStreamClass`.");
1449 bt_stream_class_set_supports_discarded_packets(
1450 this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedPackets),
1451 static_cast<bt_bool>(withDefaultClkSnapshots));
1454 bool supportsDiscardedPackets() const noexcept
1456 return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
1459 bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
1461 return static_cast<bool>(
1462 bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
1465 void defaultClockClass(const ClockClass clkCls) const
1467 static_assert(!std::is_const<LibObjT>::value,
1468 "Not available with `bt2::ConstStreamClass`.");
1471 bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
1473 BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
1476 bt2s::optional<_ClockClass> defaultClockClass() const noexcept
1478 const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
1481 return _ClockClass {libObjPtr};
1484 return bt2s::nullopt;
1487 std::uint64_t length() const noexcept
1489 return bt_stream_class_get_event_class_count(this->libObjPtr());
1492 _EventClass operator[](const std::uint64_t index) const noexcept
1494 return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
1497 bt2s::optional<_EventClass> eventClassById(const std::uint64_t id) const noexcept
1499 const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
1502 return _EventClass {libObjPtr};
1505 return bt2s::nullopt;
1508 void packetContextFieldClass(const StructureFieldClass fc) const
1510 static_assert(!std::is_const<LibObjT>::value,
1511 "Not available with `bt2::ConstStreamClass`.");
1514 bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
1516 if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1517 throw MemoryError {};
1521 bt2s::optional<_StructureFieldClass> packetContextFieldClass() const noexcept
1523 const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
1526 return _StructureFieldClass {libObjPtr};
1529 return bt2s::nullopt;
1532 void eventCommonContextFieldClass(const StructureFieldClass fc) const
1534 static_assert(!std::is_const<LibObjT>::value,
1535 "Not available with `bt2::ConstStreamClass`.");
1538 bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
1540 if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1541 throw MemoryError {};
1545 bt2s::optional<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
1547 const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
1550 return _StructureFieldClass {libObjPtr};
1553 return bt2s::nullopt;
1556 template <typename LibValT>
1557 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1559 static_assert(!std::is_const<LibObjT>::value,
1560 "Not available with `bt2::ConstStreamClass`.");
1562 bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1565 UserAttributes userAttributes() const noexcept
1567 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1570 Shared shared() const noexcept
1572 return Shared::createWithRef(*this);
1576 using StreamClass = CommonStreamClass<bt_stream_class>;
1577 using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
1579 namespace internal {
1581 struct StreamClassTypeDescr
1583 using Const = ConstStreamClass;
1584 using NonConst = StreamClass;
1588 struct TypeDescr<StreamClass> : public StreamClassTypeDescr
1593 struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
1597 } /* namespace internal */
1599 template <typename LibObjT>
1600 typename CommonEventClass<LibObjT>::_StreamClass
1601 CommonEventClass<LibObjT>::streamClass() const noexcept
1603 return _StreamClass {_Spec::streamClass(this->libObjPtr())};
1606 template <typename LibObjT>
1607 typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
1609 return Class {_Spec::cls(this->libObjPtr())};
1612 namespace internal {
1614 struct TraceClassRefFuncs final
1616 static void get(const bt_trace_class * const libObjPtr) noexcept
1618 bt_trace_class_get_ref(libObjPtr);
1621 static void put(const bt_trace_class * const libObjPtr) noexcept
1623 bt_trace_class_put_ref(libObjPtr);
1627 template <typename LibObjT>
1628 struct CommonTraceClassSpec;
1630 /* Functions specific to mutable stream classes */
1632 struct CommonTraceClassSpec<bt_trace_class> final
1634 static bt_stream_class *streamClassByIndex(bt_trace_class * const libObjPtr,
1635 const std::uint64_t index) noexcept
1637 return bt_trace_class_borrow_stream_class_by_index(libObjPtr, index);
1640 static bt_stream_class *streamClassById(bt_trace_class * const libObjPtr,
1641 const std::uint64_t id) noexcept
1643 return bt_trace_class_borrow_stream_class_by_id(libObjPtr, id);
1646 static bt_value *userAttributes(bt_trace_class * const libObjPtr) noexcept
1648 return bt_trace_class_borrow_user_attributes(libObjPtr);
1652 /* Functions specific to constant stream classes */
1654 struct CommonTraceClassSpec<const bt_trace_class> final
1656 static const bt_stream_class *streamClassByIndex(const bt_trace_class * const libObjPtr,
1657 const std::uint64_t index) noexcept
1659 return bt_trace_class_borrow_stream_class_by_index_const(libObjPtr, index);
1662 static const bt_stream_class *streamClassById(const bt_trace_class * const libObjPtr,
1663 const std::uint64_t id) noexcept
1665 return bt_trace_class_borrow_stream_class_by_id_const(libObjPtr, id);
1668 static const bt_value *userAttributes(const bt_trace_class * const libObjPtr) noexcept
1670 return bt_trace_class_borrow_user_attributes_const(libObjPtr);
1674 } /* namespace internal */
1676 template <typename LibObjT>
1677 class CommonTraceClass final : public BorrowedObject<LibObjT>
1680 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1681 using typename BorrowedObject<LibObjT>::_LibObjPtr;
1682 using _Spec = internal::CommonTraceClassSpec<LibObjT>;
1684 using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
1685 CommonStreamClass<const bt_stream_class>>;
1688 using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
1689 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1691 explicit CommonTraceClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1695 template <typename OtherLibObjT>
1696 CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
1697 _ThisBorrowedObject {traceClass}
1701 template <typename OtherLibObjT>
1702 CommonTraceClass operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
1704 _ThisBorrowedObject::operator=(traceClass);
1708 CommonTraceClass<const bt_trace_class> asConst() const noexcept
1710 return CommonTraceClass<const bt_trace_class> {*this};
1713 Trace::Shared instantiate() const
1715 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1717 const auto libObjPtr = bt_trace_create(this->libObjPtr());
1719 internal::validateCreatedObjPtr(libObjPtr);
1720 return Trace::Shared::createWithoutRef(libObjPtr);
1723 StreamClass::Shared createStreamClass() const
1725 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1727 const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
1729 internal::validateCreatedObjPtr(libObjPtr);
1730 return StreamClass::Shared::createWithoutRef(libObjPtr);
1733 StreamClass::Shared createStreamClass(const std::uint64_t id) const
1735 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1737 const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
1739 internal::validateCreatedObjPtr(libObjPtr);
1740 return StreamClass::Shared::createWithoutRef(libObjPtr);
1743 FieldClass::Shared createBoolFieldClass() const
1745 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1747 const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
1749 internal::validateCreatedObjPtr(libObjPtr);
1750 return FieldClass::Shared::createWithoutRef(libObjPtr);
1753 BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
1755 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1757 const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
1759 internal::validateCreatedObjPtr(libObjPtr);
1760 return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1763 IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
1765 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1767 const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
1769 internal::validateCreatedObjPtr(libObjPtr);
1770 return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1773 IntegerFieldClass::Shared createSignedIntegerFieldClass() const
1775 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1777 const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
1779 internal::validateCreatedObjPtr(libObjPtr);
1780 return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1783 UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
1785 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1787 const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
1789 internal::validateCreatedObjPtr(libObjPtr);
1790 return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1793 SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
1795 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1797 const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
1799 internal::validateCreatedObjPtr(libObjPtr);
1800 return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1803 FieldClass::Shared createSinglePrecisionRealFieldClass() const
1805 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1807 const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
1809 internal::validateCreatedObjPtr(libObjPtr);
1810 return FieldClass::Shared::createWithoutRef(libObjPtr);
1813 FieldClass::Shared createDoublePrecisionRealFieldClass() const
1815 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1817 const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
1819 internal::validateCreatedObjPtr(libObjPtr);
1820 return FieldClass::Shared::createWithoutRef(libObjPtr);
1823 FieldClass::Shared createStringFieldClass() const
1825 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1827 const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
1829 internal::validateCreatedObjPtr(libObjPtr);
1830 return FieldClass::Shared::createWithoutRef(libObjPtr);
1833 StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
1834 const std::uint64_t length) const
1836 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1838 const auto libObjPtr = bt_field_class_array_static_create(
1839 this->libObjPtr(), elementFieldClass.libObjPtr(), length);
1841 internal::validateCreatedObjPtr(libObjPtr);
1842 return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1845 ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
1847 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1849 const auto libObjPtr = bt_field_class_array_dynamic_create(
1850 this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
1852 internal::validateCreatedObjPtr(libObjPtr);
1853 return ArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1856 DynamicArrayWithLengthFieldClass::Shared
1857 createDynamicArrayFieldClass(const FieldClass elementFieldClass,
1858 const IntegerFieldClass lengthFieldClass) const
1860 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1862 const auto libObjPtr = bt_field_class_array_dynamic_create(
1863 this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
1865 internal::validateCreatedObjPtr(libObjPtr);
1866 return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
1869 StructureFieldClass::Shared createStructureFieldClass() const
1871 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1873 const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
1875 internal::validateCreatedObjPtr(libObjPtr);
1876 return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
1879 OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
1881 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1883 const auto libObjPtr = bt_field_class_option_without_selector_create(
1884 this->libObjPtr(), optionalFieldClass.libObjPtr());
1886 internal::validateCreatedObjPtr(libObjPtr);
1887 return OptionFieldClass::Shared::createWithoutRef(libObjPtr);
1890 OptionWithBoolSelectorFieldClass::Shared
1891 createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
1892 const FieldClass selectorFieldClass) const
1894 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1896 const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
1897 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
1899 internal::validateCreatedObjPtr(libObjPtr);
1900 return OptionWithBoolSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1903 OptionWithUnsignedIntegerSelectorFieldClass::Shared
1904 createOptionWithUnsignedIntegerSelectorFieldClass(
1905 const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
1906 const ConstUnsignedIntegerRangeSet ranges) const
1908 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1910 const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
1911 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1912 ranges.libObjPtr());
1914 internal::validateCreatedObjPtr(libObjPtr);
1915 return OptionWithUnsignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1918 OptionWithSignedIntegerSelectorFieldClass::Shared
1919 createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
1920 const IntegerFieldClass selectorFieldClass,
1921 const ConstSignedIntegerRangeSet ranges) const
1923 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1925 const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
1926 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1927 ranges.libObjPtr());
1929 internal::validateCreatedObjPtr(libObjPtr);
1930 return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1933 VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
1935 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1937 const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
1939 internal::validateCreatedObjPtr(libObjPtr);
1940 return VariantWithoutSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1943 VariantWithUnsignedIntegerSelectorFieldClass::Shared
1944 createVariantWithUnsignedIntegerSelectorFieldClass(
1945 const IntegerFieldClass selectorFieldClass) const
1947 return this->_createVariantWithIntegerSelectorFieldClass<
1948 VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
1951 VariantWithSignedIntegerSelectorFieldClass::Shared
1952 createVariantWithSignedIntegerSelectorFieldClass(
1953 const IntegerFieldClass selectorFieldClass) const
1955 return this->_createVariantWithIntegerSelectorFieldClass<
1956 VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
1959 void assignsAutomaticStreamClassId(const bool val) const noexcept
1961 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1963 bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
1964 static_cast<bt_bool>(val));
1967 bool assignsAutomaticStreamClassId() const noexcept
1969 return static_cast<bool>(
1970 bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
1973 std::uint64_t length() const noexcept
1975 return bt_trace_class_get_stream_class_count(this->libObjPtr());
1978 _StreamClass operator[](const std::uint64_t index) const noexcept
1980 return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
1983 bt2s::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
1985 const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
1988 return _StreamClass {libObjPtr};
1991 return bt2s::nullopt;
1994 template <typename LibValT>
1995 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1997 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1999 bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
2002 UserAttributes userAttributes() const noexcept
2004 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
2007 Shared shared() const noexcept
2009 return Shared::createWithRef(*this);
2013 template <typename ObjT>
2014 typename ObjT::Shared
2015 _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
2017 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
2019 const auto libObjPtr =
2020 bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
2022 internal::validateCreatedObjPtr(libObjPtr);
2023 return ObjT::Shared::createWithoutRef(libObjPtr);
2027 using TraceClass = CommonTraceClass<bt_trace_class>;
2028 using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
2030 namespace internal {
2032 struct TraceClassTypeDescr
2034 using Const = ConstTraceClass;
2035 using NonConst = TraceClass;
2039 struct TypeDescr<TraceClass> : public TraceClassTypeDescr
2044 struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
2048 } /* namespace internal */
2050 template <typename LibObjT>
2051 typename CommonStreamClass<LibObjT>::_TraceClass
2052 CommonStreamClass<LibObjT>::traceClass() const noexcept
2054 return _TraceClass {_Spec::traceClass(this->libObjPtr())};
2057 template <typename LibObjT>
2058 typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
2060 return Class {_Spec::cls(this->libObjPtr())};
2063 } /* namespace bt2 */
2065 #endif /* BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP */