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 _Spec = internal::CommonEventSpec<LibObjT>;
134 using _Packet = internal::DepPacket<LibObjT>;
135 using _Stream = internal::DepStream<LibObjT>;
136 using _StructureField = internal::DepStructField<LibObjT>;
139 using typename BorrowedObject<LibObjT>::LibObjPtr;
141 using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
142 CommonEventClass<const bt_event_class>>;
144 explicit CommonEvent(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
148 template <typename OtherLibObjT>
149 CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
153 template <typename OtherLibObjT>
154 CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
156 _ThisBorrowedObject::operator=(event);
160 CommonEvent<const bt_event> asConst() const noexcept
162 return CommonEvent<const bt_event> {*this};
165 Class cls() const noexcept;
166 _Stream stream() const noexcept;
167 bt2s::optional<_Packet> packet() const noexcept;
169 bt2s::optional<_StructureField> payloadField() const noexcept
171 const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
174 return _StructureField {libObjPtr};
177 return bt2s::nullopt;
180 bt2s::optional<_StructureField> specificContextField() const noexcept
182 const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
185 return _StructureField {libObjPtr};
188 return bt2s::nullopt;
191 bt2s::optional<_StructureField> commonContextField() const noexcept
193 const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
196 return _StructureField {libObjPtr};
199 return bt2s::nullopt;
203 using Event = CommonEvent<bt_event>;
204 using ConstEvent = CommonEvent<const bt_event>;
208 struct EventTypeDescr
210 using Const = ConstEvent;
211 using NonConst = Event;
215 struct TypeDescr<Event> : public EventTypeDescr
220 struct TypeDescr<ConstEvent> : public EventTypeDescr
224 struct PacketRefFuncs final
226 static void get(const bt_packet * const libObjPtr) noexcept
228 bt_packet_get_ref(libObjPtr);
231 static void put(const bt_packet * const libObjPtr) noexcept
233 bt_packet_put_ref(libObjPtr);
237 template <typename LibObjT>
238 struct CommonPacketSpec;
240 /* Functions specific to mutable packets */
242 struct CommonPacketSpec<bt_packet> final
244 static bt_stream *stream(bt_packet * const libObjPtr) noexcept
246 return bt_packet_borrow_stream(libObjPtr);
249 static bt_field *contextField(bt_packet * const libObjPtr) noexcept
251 return bt_packet_borrow_context_field(libObjPtr);
255 /* Functions specific to constant packets */
257 struct CommonPacketSpec<const bt_packet> final
259 static const bt_stream *stream(const bt_packet * const libObjPtr) noexcept
261 return bt_packet_borrow_stream_const(libObjPtr);
264 static const bt_field *contextField(const bt_packet * const libObjPtr) noexcept
266 return bt_packet_borrow_context_field_const(libObjPtr);
270 } /* namespace internal */
272 template <typename LibObjT>
273 class CommonPacket final : public BorrowedObject<LibObjT>
276 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
277 using _Spec = internal::CommonPacketSpec<LibObjT>;
278 using _Stream = internal::DepStream<LibObjT>;
279 using _StructureField = internal::DepStructField<LibObjT>;
282 using typename BorrowedObject<LibObjT>::LibObjPtr;
283 using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
285 explicit CommonPacket(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
289 template <typename OtherLibObjT>
290 CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
294 template <typename OtherLibObjT>
295 CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
297 _ThisBorrowedObject::operator=(packet);
301 CommonPacket<const bt_packet> asConst() const noexcept
303 return CommonPacket<const bt_packet> {*this};
306 _Stream stream() const noexcept;
308 bt2s::optional<_StructureField> contextField() const noexcept
310 const auto libObjPtr = _Spec::contextField(this->libObjPtr());
313 return _StructureField {libObjPtr};
316 return bt2s::nullopt;
319 Shared shared() const noexcept
321 return Shared::createWithRef(*this);
325 using Packet = CommonPacket<bt_packet>;
326 using ConstPacket = CommonPacket<const bt_packet>;
330 struct PacketTypeDescr
332 using Const = ConstPacket;
333 using NonConst = Packet;
337 struct TypeDescr<Packet> : public PacketTypeDescr
342 struct TypeDescr<ConstPacket> : public PacketTypeDescr
346 } /* namespace internal */
348 template <typename LibObjT>
349 bt2s::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() const noexcept
351 const auto libObjPtr = _Spec::packet(this->libObjPtr());
354 return _Packet {libObjPtr};
357 return bt2s::nullopt;
362 struct StreamRefFuncs final
364 static void get(const bt_stream * const libObjPtr) noexcept
366 bt_stream_get_ref(libObjPtr);
369 static void put(const bt_stream * const libObjPtr) noexcept
371 bt_stream_put_ref(libObjPtr);
375 template <typename LibObjT>
376 struct CommonStreamSpec;
378 /* Functions specific to mutable streams */
380 struct CommonStreamSpec<bt_stream> final
382 static bt_stream_class *cls(bt_stream * const libObjPtr) noexcept
384 return bt_stream_borrow_class(libObjPtr);
387 static bt_trace *trace(bt_stream * const libObjPtr) noexcept
389 return bt_stream_borrow_trace(libObjPtr);
392 static bt_value *userAttributes(bt_stream * const libObjPtr) noexcept
394 return bt_stream_borrow_user_attributes(libObjPtr);
398 /* Functions specific to constant streams */
400 struct CommonStreamSpec<const bt_stream> final
402 static const bt_stream_class *cls(const bt_stream * const libObjPtr) noexcept
404 return bt_stream_borrow_class_const(libObjPtr);
407 static const bt_trace *trace(const bt_stream * const libObjPtr) noexcept
409 return bt_stream_borrow_trace_const(libObjPtr);
412 static const bt_value *userAttributes(const bt_stream * const libObjPtr) noexcept
414 return bt_stream_borrow_user_attributes_const(libObjPtr);
418 } /* namespace internal */
420 template <typename LibObjT>
421 class CommonStream final : public BorrowedObject<LibObjT>
424 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
425 using _Spec = internal::CommonStreamSpec<LibObjT>;
426 using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
429 using typename BorrowedObject<LibObjT>::LibObjPtr;
430 using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
431 using UserAttributes = internal::DepUserAttrs<LibObjT>;
433 using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
434 CommonStreamClass<const bt_stream_class>>;
436 explicit CommonStream(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
440 template <typename OtherLibObjT>
441 CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObject {stream}
445 template <typename OtherLibObjT>
446 CommonStream operator=(const CommonStream<OtherLibObjT> stream) noexcept
448 _ThisBorrowedObject::operator=(stream);
452 CommonStream<const bt_stream> asConst() const noexcept
454 return CommonStream<const bt_stream> {*this};
457 Packet::Shared createPacket() const
459 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
461 const auto libObjPtr = bt_packet_create(this->libObjPtr());
463 internal::validateCreatedObjPtr(libObjPtr);
464 return Packet::Shared::createWithoutRef(libObjPtr);
467 Class cls() const noexcept;
468 _Trace trace() const noexcept;
470 std::uint64_t id() const noexcept
472 return bt_stream_get_id(this->libObjPtr());
475 void name(const char * const name) const
477 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
479 const auto status = bt_stream_set_name(this->libObjPtr(), name);
481 if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
482 throw MemoryError {};
486 void name(const std::string& name) const
488 this->name(name.data());
491 const char *name() const noexcept
493 return bt_stream_get_name(this->libObjPtr());
496 template <typename LibValT>
497 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
499 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
501 bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
504 UserAttributes userAttributes() const noexcept
506 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
509 Shared shared() const noexcept
511 return Shared::createWithRef(*this);
515 using Stream = CommonStream<bt_stream>;
516 using ConstStream = CommonStream<const bt_stream>;
520 struct StreamTypeDescr
522 using Const = ConstStream;
523 using NonConst = Stream;
527 struct TypeDescr<Stream> : public StreamTypeDescr
532 struct TypeDescr<ConstStream> : public StreamTypeDescr
536 } /* namespace internal */
538 template <typename LibObjT>
539 typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
541 return _Stream {_Spec::stream(this->libObjPtr())};
544 template <typename LibObjT>
545 typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
547 return _Stream {_Spec::stream(this->libObjPtr())};
552 struct TraceRefFuncs final
554 static void get(const bt_trace * const libObjPtr) noexcept
556 bt_trace_get_ref(libObjPtr);
559 static void put(const bt_trace * const libObjPtr) noexcept
561 bt_trace_put_ref(libObjPtr);
565 template <typename LibObjT>
566 struct CommonTraceSpec;
568 /* Functions specific to mutable traces */
570 struct CommonTraceSpec<bt_trace> final
572 static bt_trace_class *cls(bt_trace * const libObjPtr) noexcept
574 return bt_trace_borrow_class(libObjPtr);
577 static bt_stream *streamByIndex(bt_trace * const libObjPtr, const std::uint64_t index) noexcept
579 return bt_trace_borrow_stream_by_index(libObjPtr, index);
582 static bt_stream *streamById(bt_trace * const libObjPtr, const std::uint64_t id) noexcept
584 return bt_trace_borrow_stream_by_id(libObjPtr, id);
587 static bt_value *userAttributes(bt_trace * const libObjPtr) noexcept
589 return bt_trace_borrow_user_attributes(libObjPtr);
593 /* Functions specific to constant traces */
595 struct CommonTraceSpec<const bt_trace> final
597 static const bt_trace_class *cls(const bt_trace * const libObjPtr) noexcept
599 return bt_trace_borrow_class_const(libObjPtr);
602 static const bt_stream *streamByIndex(const bt_trace * const libObjPtr,
603 const std::uint64_t index) noexcept
605 return bt_trace_borrow_stream_by_index_const(libObjPtr, index);
608 static const bt_stream *streamById(const bt_trace * const libObjPtr,
609 const std::uint64_t id) noexcept
611 return bt_trace_borrow_stream_by_id_const(libObjPtr, id);
614 static const bt_value *userAttributes(const bt_trace * const libObjPtr) noexcept
616 return bt_trace_borrow_user_attributes_const(libObjPtr);
620 } /* namespace internal */
622 template <typename LibObjT>
623 class CommonTrace final : public BorrowedObject<LibObjT>
626 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
627 using _Spec = internal::CommonTraceSpec<LibObjT>;
628 using _Stream = internal::DepStream<LibObjT>;
631 using typename BorrowedObject<LibObjT>::LibObjPtr;
632 using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
633 using UserAttributes = internal::DepUserAttrs<LibObjT>;
635 using Class = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
636 CommonTraceClass<const bt_trace_class>>;
638 struct ConstEnvironmentEntry
644 explicit CommonTrace(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
648 template <typename OtherLibObjT>
649 CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObject {trace}
653 template <typename OtherLibObjT>
654 CommonTrace operator=(const CommonTrace<OtherLibObjT> trace) noexcept
656 _ThisBorrowedObject::operator=(trace);
660 CommonTrace<const bt_trace> asConst() const noexcept
662 return CommonTrace<const bt_trace> {*this};
665 Class cls() const noexcept;
667 void name(const char * const name) const
669 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
671 const auto status = bt_trace_set_name(this->libObjPtr(), name);
673 if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
674 throw MemoryError {};
678 void name(const std::string& name) const
680 this->name(name.data());
683 const char *name() const noexcept
685 return bt_trace_get_name(this->libObjPtr());
688 void uuid(const bt2c::UuidView& uuid) const noexcept
690 bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
693 bt2s::optional<bt2c::UuidView> uuid() const noexcept
695 const auto uuid = bt_trace_get_uuid(this->libObjPtr());
698 return bt2c::UuidView {uuid};
701 return bt2s::nullopt;
704 std::uint64_t length() const noexcept
706 return bt_trace_get_stream_count(this->libObjPtr());
709 _Stream operator[](const std::uint64_t index) const noexcept
711 return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
714 bt2s::optional<_Stream> streamById(const std::uint64_t id) const noexcept
716 const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
719 return _Stream {libObjPtr};
722 return bt2s::nullopt;
725 void environmentEntry(const char * const name, const std::int64_t val) const
727 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
729 const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
731 if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
732 throw MemoryError {};
736 void environmentEntry(const std::string& name, const std::int64_t val) const
738 this->environmentEntry(name.data(), val);
741 void environmentEntry(const char * const name, const char * const val) const
743 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
745 const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
747 if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
748 throw MemoryError {};
752 void environmentEntry(const std::string& name, const char * const val) const
754 this->environmentEntry(name.data(), val);
757 void environmentEntry(const char * const name, const std::string& val) const
759 this->environmentEntry(name, val.data());
762 void environmentEntry(const std::string& name, const std::string& val) const
764 this->environmentEntry(name.data(), val.data());
767 std::uint64_t environmentSize() const noexcept
769 return bt_trace_get_environment_entry_count(this->libObjPtr());
772 ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
775 const bt_value *libObjPtr;
777 bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
779 return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
782 bt2s::optional<ConstValue> environmentEntry(const char * const name) const noexcept
784 const auto libObjPtr =
785 bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
788 return ConstValue {libObjPtr};
791 return bt2s::nullopt;
794 bt2s::optional<ConstValue> environmentEntry(const std::string& name) const noexcept
796 return this->environmentEntry(name.data());
799 template <typename LibValT>
800 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
802 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
804 bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
807 UserAttributes userAttributes() const noexcept
809 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
812 Shared shared() const noexcept
814 return Shared::createWithRef(*this);
818 using Trace = CommonTrace<bt_trace>;
819 using ConstTrace = CommonTrace<const bt_trace>;
823 struct TraceTypeDescr
825 using Const = ConstTrace;
826 using NonConst = Trace;
830 struct TypeDescr<Trace> : public TraceTypeDescr
835 struct TypeDescr<ConstTrace> : public TraceTypeDescr
839 } /* namespace internal */
841 template <typename LibObjT>
842 typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
844 return _Trace {_Spec::trace(this->libObjPtr())};
849 struct EventClassRefFuncs final
851 static void get(const bt_event_class * const libObjPtr) noexcept
853 bt_event_class_get_ref(libObjPtr);
856 static void put(const bt_event_class * const libObjPtr) noexcept
858 bt_event_class_put_ref(libObjPtr);
862 template <typename LibObjT>
863 struct CommonEventClassSpec;
865 /* Functions specific to mutable event classes */
867 struct CommonEventClassSpec<bt_event_class> final
869 static bt_stream_class *streamClass(bt_event_class * const libObjPtr) noexcept
871 return bt_event_class_borrow_stream_class(libObjPtr);
874 static bt_field_class *payloadFieldClass(bt_event_class * const libObjPtr) noexcept
876 return bt_event_class_borrow_payload_field_class(libObjPtr);
879 static bt_field_class *specificContextFieldClass(bt_event_class * const libObjPtr) noexcept
881 return bt_event_class_borrow_specific_context_field_class(libObjPtr);
884 static bt_value *userAttributes(bt_event_class * const libObjPtr) noexcept
886 return bt_event_class_borrow_user_attributes(libObjPtr);
890 /* Functions specific to constant event classes */
892 struct CommonEventClassSpec<const bt_event_class> final
894 static const bt_stream_class *streamClass(const bt_event_class * const libObjPtr) noexcept
896 return bt_event_class_borrow_stream_class_const(libObjPtr);
899 static const bt_field_class *payloadFieldClass(const bt_event_class * const libObjPtr) noexcept
901 return bt_event_class_borrow_payload_field_class_const(libObjPtr);
904 static const bt_field_class *
905 specificContextFieldClass(const bt_event_class * const libObjPtr) noexcept
907 return bt_event_class_borrow_specific_context_field_class_const(libObjPtr);
910 static const bt_value *userAttributes(const bt_event_class * const libObjPtr) noexcept
912 return bt_event_class_borrow_user_attributes_const(libObjPtr);
916 template <typename LibObjT>
917 using DepStructFc = DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
919 } /* namespace internal */
921 template <typename LibObjT>
922 class CommonEventClass final : public BorrowedObject<LibObjT>
925 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
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 typename BorrowedObject<LibObjT>::LibObjPtr;
934 using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
935 using UserAttributes = internal::DepUserAttrs<LibObjT>;
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,
956 explicit CommonEventClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
960 template <typename OtherLibObjT>
961 CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
962 _ThisBorrowedObject {eventClass}
966 template <typename OtherLibObjT>
967 CommonEventClass operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
969 _ThisBorrowedObject::operator=(eventClass);
973 CommonEventClass<const bt_event_class> asConst() const noexcept
975 return CommonEventClass<const bt_event_class> {*this};
978 _StreamClass streamClass() const noexcept;
980 std::uint64_t id() const noexcept
982 return bt_event_class_get_id(this->libObjPtr());
985 void name(const char * const name) const
987 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
989 const auto status = bt_event_class_set_name(this->libObjPtr(), name);
991 if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
992 throw MemoryError {};
996 void name(const std::string& name) const
998 this->name(name.data());
1001 const char *name() const noexcept
1003 return bt_event_class_get_name(this->libObjPtr());
1006 void logLevel(const LogLevel logLevel) const noexcept
1008 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1010 bt_event_class_set_log_level(this->libObjPtr(),
1011 static_cast<bt_event_class_log_level>(logLevel));
1014 bt2s::optional<LogLevel> logLevel() const noexcept
1016 bt_event_class_log_level libLogLevel;
1017 const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
1019 if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
1020 return static_cast<LogLevel>(libLogLevel);
1023 return bt2s::nullopt;
1026 void emfUri(const char * const emfUri) const
1028 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1030 const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
1032 if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
1033 throw MemoryError {};
1037 void emfUri(const std::string& emfUri) const
1039 this->emfUri(emfUri.data());
1042 const char *emfUri() const noexcept
1044 return bt_event_class_get_emf_uri(this->libObjPtr());
1047 void payloadFieldClass(const StructureFieldClass fc) const
1049 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1052 bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
1054 if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1055 throw MemoryError {};
1059 bt2s::optional<_StructureFieldClass> payloadFieldClass() const noexcept
1061 const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
1064 return _StructureFieldClass {libObjPtr};
1067 return bt2s::nullopt;
1070 void specificContextFieldClass(const StructureFieldClass fc) const
1072 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1075 bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
1077 if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1078 throw MemoryError {};
1082 bt2s::optional<_StructureFieldClass> specificContextFieldClass() const noexcept
1084 const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
1087 return _StructureFieldClass {libObjPtr};
1090 return bt2s::nullopt;
1093 template <typename LibValT>
1094 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1096 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1098 bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1101 UserAttributes userAttributes() const noexcept
1103 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1106 Shared shared() const noexcept
1108 return Shared::createWithRef(*this);
1112 using EventClass = CommonEventClass<bt_event_class>;
1113 using ConstEventClass = CommonEventClass<const bt_event_class>;
1115 namespace internal {
1117 struct EventClassTypeDescr
1119 using Const = ConstEventClass;
1120 using NonConst = EventClass;
1124 struct TypeDescr<EventClass> : public EventClassTypeDescr
1129 struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
1133 } /* namespace internal */
1135 template <typename LibObjT>
1136 typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
1138 return Class {_Spec::cls(this->libObjPtr())};
1141 namespace internal {
1143 struct StreamClassRefFuncs final
1145 static void get(const bt_stream_class * const libObjPtr) noexcept
1147 bt_stream_class_get_ref(libObjPtr);
1150 static void put(const bt_stream_class * const libObjPtr) noexcept
1152 bt_stream_class_put_ref(libObjPtr);
1156 template <typename LibObjT>
1157 struct CommonStreamClassSpec;
1159 /* Functions specific to mutable stream classes */
1161 struct CommonStreamClassSpec<bt_stream_class> final
1163 static bt_trace_class *traceClass(bt_stream_class * const libObjPtr) noexcept
1165 return bt_stream_class_borrow_trace_class(libObjPtr);
1168 static bt_event_class *eventClassByIndex(bt_stream_class * const libObjPtr,
1169 const std::uint64_t index) noexcept
1171 return bt_stream_class_borrow_event_class_by_index(libObjPtr, index);
1174 static bt_event_class *eventClassById(bt_stream_class * const libObjPtr,
1175 const std::uint64_t id) noexcept
1177 return bt_stream_class_borrow_event_class_by_id(libObjPtr, id);
1180 static bt_clock_class *defaultClockClass(bt_stream_class * const libObjPtr) noexcept
1182 return bt_stream_class_borrow_default_clock_class(libObjPtr);
1185 static bt_field_class *packetContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1187 return bt_stream_class_borrow_packet_context_field_class(libObjPtr);
1190 static bt_field_class *eventCommonContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1192 return bt_stream_class_borrow_event_common_context_field_class(libObjPtr);
1195 static bt_value *userAttributes(bt_stream_class * const libObjPtr) noexcept
1197 return bt_stream_class_borrow_user_attributes(libObjPtr);
1201 /* Functions specific to constant stream classes */
1203 struct CommonStreamClassSpec<const bt_stream_class> final
1205 static const bt_trace_class *traceClass(const bt_stream_class * const libObjPtr) noexcept
1207 return bt_stream_class_borrow_trace_class_const(libObjPtr);
1210 static const bt_event_class *eventClassByIndex(const bt_stream_class * const libObjPtr,
1211 const std::uint64_t index) noexcept
1213 return bt_stream_class_borrow_event_class_by_index_const(libObjPtr, index);
1216 static const bt_event_class *eventClassById(const bt_stream_class * const libObjPtr,
1217 const std::uint64_t id) noexcept
1219 return bt_stream_class_borrow_event_class_by_id_const(libObjPtr, id);
1222 static const bt_clock_class *defaultClockClass(const bt_stream_class * const libObjPtr) noexcept
1224 return bt_stream_class_borrow_default_clock_class_const(libObjPtr);
1227 static const bt_field_class *
1228 packetContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1230 return bt_stream_class_borrow_packet_context_field_class_const(libObjPtr);
1233 static const bt_field_class *
1234 eventCommonContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1236 return bt_stream_class_borrow_event_common_context_field_class_const(libObjPtr);
1239 static const bt_value *userAttributes(const bt_stream_class * const libObjPtr) noexcept
1241 return bt_stream_class_borrow_user_attributes_const(libObjPtr);
1245 } /* namespace internal */
1247 template <typename LibObjT>
1248 class CommonStreamClass final : public BorrowedObject<LibObjT>
1251 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
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 typename BorrowedObject<LibObjT>::LibObjPtr;
1265 using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
1266 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1268 explicit CommonStreamClass(const LibObjPtr libObjPtr) noexcept : _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;
1682 using _Spec = internal::CommonTraceClassSpec<LibObjT>;
1684 using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
1685 CommonStreamClass<const bt_stream_class>>;
1688 using typename BorrowedObject<LibObjT>::LibObjPtr;
1689 using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
1690 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1692 explicit CommonTraceClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1696 template <typename OtherLibObjT>
1697 CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
1698 _ThisBorrowedObject {traceClass}
1702 template <typename OtherLibObjT>
1703 CommonTraceClass operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
1705 _ThisBorrowedObject::operator=(traceClass);
1709 CommonTraceClass<const bt_trace_class> asConst() const noexcept
1711 return CommonTraceClass<const bt_trace_class> {*this};
1714 Trace::Shared instantiate() const
1716 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1718 const auto libObjPtr = bt_trace_create(this->libObjPtr());
1720 internal::validateCreatedObjPtr(libObjPtr);
1721 return Trace::Shared::createWithoutRef(libObjPtr);
1724 StreamClass::Shared createStreamClass() const
1726 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1728 const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
1730 internal::validateCreatedObjPtr(libObjPtr);
1731 return StreamClass::Shared::createWithoutRef(libObjPtr);
1734 StreamClass::Shared createStreamClass(const std::uint64_t id) const
1736 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1738 const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
1740 internal::validateCreatedObjPtr(libObjPtr);
1741 return StreamClass::Shared::createWithoutRef(libObjPtr);
1744 FieldClass::Shared createBoolFieldClass() const
1746 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1748 const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
1750 internal::validateCreatedObjPtr(libObjPtr);
1751 return FieldClass::Shared::createWithoutRef(libObjPtr);
1754 BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
1756 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1758 const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
1760 internal::validateCreatedObjPtr(libObjPtr);
1761 return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1764 IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
1766 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1768 const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
1770 internal::validateCreatedObjPtr(libObjPtr);
1771 return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1774 IntegerFieldClass::Shared createSignedIntegerFieldClass() const
1776 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1778 const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
1780 internal::validateCreatedObjPtr(libObjPtr);
1781 return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1784 UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
1786 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1788 const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
1790 internal::validateCreatedObjPtr(libObjPtr);
1791 return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1794 SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
1796 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1798 const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
1800 internal::validateCreatedObjPtr(libObjPtr);
1801 return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1804 FieldClass::Shared createSinglePrecisionRealFieldClass() const
1806 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1808 const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
1810 internal::validateCreatedObjPtr(libObjPtr);
1811 return FieldClass::Shared::createWithoutRef(libObjPtr);
1814 FieldClass::Shared createDoublePrecisionRealFieldClass() const
1816 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1818 const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
1820 internal::validateCreatedObjPtr(libObjPtr);
1821 return FieldClass::Shared::createWithoutRef(libObjPtr);
1824 FieldClass::Shared createStringFieldClass() const
1826 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1828 const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
1830 internal::validateCreatedObjPtr(libObjPtr);
1831 return FieldClass::Shared::createWithoutRef(libObjPtr);
1834 StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
1835 const std::uint64_t length) const
1837 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1839 const auto libObjPtr = bt_field_class_array_static_create(
1840 this->libObjPtr(), elementFieldClass.libObjPtr(), length);
1842 internal::validateCreatedObjPtr(libObjPtr);
1843 return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1846 ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
1848 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1850 const auto libObjPtr = bt_field_class_array_dynamic_create(
1851 this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
1853 internal::validateCreatedObjPtr(libObjPtr);
1854 return ArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1857 DynamicArrayWithLengthFieldClass::Shared
1858 createDynamicArrayFieldClass(const FieldClass elementFieldClass,
1859 const IntegerFieldClass lengthFieldClass) const
1861 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1863 const auto libObjPtr = bt_field_class_array_dynamic_create(
1864 this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
1866 internal::validateCreatedObjPtr(libObjPtr);
1867 return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
1870 StructureFieldClass::Shared createStructureFieldClass() const
1872 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1874 const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
1876 internal::validateCreatedObjPtr(libObjPtr);
1877 return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
1880 OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
1882 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1884 const auto libObjPtr = bt_field_class_option_without_selector_create(
1885 this->libObjPtr(), optionalFieldClass.libObjPtr());
1887 internal::validateCreatedObjPtr(libObjPtr);
1888 return OptionFieldClass::Shared::createWithoutRef(libObjPtr);
1891 OptionWithBoolSelectorFieldClass::Shared
1892 createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
1893 const FieldClass selectorFieldClass) const
1895 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1897 const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
1898 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
1900 internal::validateCreatedObjPtr(libObjPtr);
1901 return OptionWithBoolSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1904 OptionWithUnsignedIntegerSelectorFieldClass::Shared
1905 createOptionWithUnsignedIntegerSelectorFieldClass(
1906 const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
1907 const ConstUnsignedIntegerRangeSet ranges) const
1909 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1911 const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
1912 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1913 ranges.libObjPtr());
1915 internal::validateCreatedObjPtr(libObjPtr);
1916 return OptionWithUnsignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1919 OptionWithSignedIntegerSelectorFieldClass::Shared
1920 createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
1921 const IntegerFieldClass selectorFieldClass,
1922 const ConstSignedIntegerRangeSet ranges) const
1924 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1926 const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
1927 this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1928 ranges.libObjPtr());
1930 internal::validateCreatedObjPtr(libObjPtr);
1931 return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1934 VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
1936 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1938 const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
1940 internal::validateCreatedObjPtr(libObjPtr);
1941 return VariantWithoutSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1944 VariantWithUnsignedIntegerSelectorFieldClass::Shared
1945 createVariantWithUnsignedIntegerSelectorFieldClass(
1946 const IntegerFieldClass selectorFieldClass) const
1948 return this->_createVariantWithIntegerSelectorFieldClass<
1949 VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
1952 VariantWithSignedIntegerSelectorFieldClass::Shared
1953 createVariantWithSignedIntegerSelectorFieldClass(
1954 const IntegerFieldClass selectorFieldClass) const
1956 return this->_createVariantWithIntegerSelectorFieldClass<
1957 VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
1960 void assignsAutomaticStreamClassId(const bool val) const noexcept
1962 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1964 bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
1965 static_cast<bt_bool>(val));
1968 bool assignsAutomaticStreamClassId() const noexcept
1970 return static_cast<bool>(
1971 bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
1974 std::uint64_t length() const noexcept
1976 return bt_trace_class_get_stream_class_count(this->libObjPtr());
1979 _StreamClass operator[](const std::uint64_t index) const noexcept
1981 return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
1984 bt2s::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
1986 const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
1989 return _StreamClass {libObjPtr};
1992 return bt2s::nullopt;
1995 template <typename LibValT>
1996 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1998 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
2000 bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
2003 UserAttributes userAttributes() const noexcept
2005 return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
2008 Shared shared() const noexcept
2010 return Shared::createWithRef(*this);
2014 template <typename ObjT>
2015 typename ObjT::Shared
2016 _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
2018 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
2020 const auto libObjPtr =
2021 bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
2023 internal::validateCreatedObjPtr(libObjPtr);
2024 return ObjT::Shared::createWithoutRef(libObjPtr);
2028 using TraceClass = CommonTraceClass<bt_trace_class>;
2029 using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
2031 namespace internal {
2033 struct TraceClassTypeDescr
2035 using Const = ConstTraceClass;
2036 using NonConst = TraceClass;
2040 struct TypeDescr<TraceClass> : public TraceClassTypeDescr
2045 struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
2049 } /* namespace internal */
2051 template <typename LibObjT>
2052 typename CommonStreamClass<LibObjT>::_TraceClass
2053 CommonStreamClass<LibObjT>::traceClass() const noexcept
2055 return _TraceClass {_Spec::traceClass(this->libObjPtr())};
2058 template <typename LibObjT>
2059 typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
2061 return Class {_Spec::cls(this->libObjPtr())};
2064 } /* namespace bt2 */
2066 #endif /* BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP */