#ifndef BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
#define BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
-#include <type_traits>
#include <cstdint>
+#include <type_traits>
+
#include <babeltrace2/babeltrace.h>
-#include "internal/borrowed-obj.hpp"
-#include "cpp-common/optional.hpp"
-#include "cpp-common/string_view.hpp"
+#include "cpp-common/bt2c/c-string-view.hpp"
+#include "cpp-common/bt2s/optional.hpp"
+
+#include "borrowed-object.hpp"
#include "clock-class.hpp"
-#include "clock-snapshot.hpp"
#include "field-class.hpp"
#include "field.hpp"
-#include "value.hpp"
#include "internal/utils.hpp"
+#include "optional-borrowed-object.hpp"
+#include "shared-object.hpp"
+#include "value.hpp"
namespace bt2 {
template <typename LibObjT>
struct CommonEventSpec;
-// Functions specific to mutable events
+/* Functions specific to mutable events */
template <>
struct CommonEventSpec<bt_event> final
{
}
};
-// Functions specific to constant events
+/* Functions specific to constant events */
template <>
struct CommonEventSpec<const bt_event> final
{
}
};
-} // namespace internal
+template <typename LibObjT>
+using DepStructField = DepType<LibObjT, StructureField, ConstStructureField>;
+
+} /* namespace internal */
template <typename LibObjT>
-class CommonEvent final : public internal::BorrowedObj<LibObjT>
+class CommonEvent final : public BorrowedObject<LibObjT>
{
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonEventSpec<const bt_event>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _Spec = internal::CommonEventSpec<LibObjT>;
-
- using _Packet =
- typename std::conditional<std::is_const<LibObjT>::value, CommonPacket<const bt_packet>,
- CommonPacket<bt_packet>>::type;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
-
- using _StructureField = typename std::conditional<std::is_const<LibObjT>::value,
- ConstStructureField, StructureField>::type;
+ using _Packet = internal::DepPacket<LibObjT>;
+ using _Stream = internal::DepStream<LibObjT>;
+ using _StructureField = internal::DepStructField<LibObjT>;
public:
- using Class = typename std::conditional<std::is_const<LibObjT>::value,
- CommonEventClass<const bt_event_class>,
- CommonEventClass<bt_event_class>>::type;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
- explicit CommonEvent(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
+ CommonEventClass<const bt_event_class>>;
+
+ explicit CommonEvent(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonEvent(const CommonEvent<OtherLibObjT>& event) noexcept : _ThisBorrowedObj {event}
+ CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
{
}
template <typename OtherLibObjT>
- CommonEvent<LibObjT>& operator=(const CommonEvent<OtherLibObjT>& event) noexcept
+ CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
{
- _ThisBorrowedObj::operator=(event);
+ _ThisBorrowedObject::operator=(event);
return *this;
}
- CommonEventClass<const bt_event_class> cls() const noexcept;
- Class cls() noexcept;
- CommonStream<const bt_stream> stream() const noexcept;
- _Stream stream() noexcept;
- nonstd::optional<CommonPacket<const bt_packet>> packet() const noexcept;
- nonstd::optional<_Packet> packet() noexcept;
-
- nonstd::optional<ConstStructureField> payloadField() const noexcept
- {
- const auto libObjPtr = _ConstSpec::payloadField(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureField> payloadField() noexcept
+ CommonEvent<const bt_event> asConst() const noexcept
{
- const auto libObjPtr = _Spec::payloadField(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return CommonEvent<const bt_event> {*this};
}
- nonstd::optional<ConstStructureField> specificContextField() const noexcept
- {
- const auto libObjPtr = _ConstSpec::specificContextField(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
+ Class cls() const noexcept;
+ _Stream stream() const noexcept;
+ OptionalBorrowedObject<_Packet> packet() const noexcept;
- nonstd::optional<_StructureField> specificContextField() noexcept
+ OptionalBorrowedObject<_StructureField> payloadField() const noexcept
{
- const auto libObjPtr = _Spec::specificContextField(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::payloadField(this->libObjPtr());
}
- nonstd::optional<ConstStructureField> commonContextField() const noexcept
+ OptionalBorrowedObject<_StructureField> specificContextField() const noexcept
{
- const auto libObjPtr = _ConstSpec::commonContextField(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::specificContextField(this->libObjPtr());
}
- nonstd::optional<_StructureField> commonContextField() noexcept
+ OptionalBorrowedObject<_StructureField> commonContextField() const noexcept
{
- const auto libObjPtr = _Spec::commonContextField(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::commonContextField(this->libObjPtr());
}
};
namespace internal {
+struct EventTypeDescr
+{
+ using Const = ConstEvent;
+ using NonConst = Event;
+};
+
+template <>
+struct TypeDescr<Event> : public EventTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEvent> : public EventTypeDescr
+{
+};
+
struct PacketRefFuncs final
{
- static void get(const bt_packet * const libObjPtr)
+ static void get(const bt_packet * const libObjPtr) noexcept
{
bt_packet_get_ref(libObjPtr);
}
- static void put(const bt_packet * const libObjPtr)
+ static void put(const bt_packet * const libObjPtr) noexcept
{
bt_packet_put_ref(libObjPtr);
}
template <typename LibObjT>
struct CommonPacketSpec;
-// Functions specific to mutable packets
+/* Functions specific to mutable packets */
template <>
struct CommonPacketSpec<bt_packet> final
{
}
};
-// Functions specific to constant packets
+/* Functions specific to constant packets */
template <>
struct CommonPacketSpec<const bt_packet> final
{
}
};
-} // namespace internal
+} /* namespace internal */
template <typename LibObjT>
-class CommonPacket final : public internal::BorrowedObj<LibObjT>
+class CommonPacket final : public BorrowedObject<LibObjT>
{
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonPacketSpec<const bt_packet>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _Spec = internal::CommonPacketSpec<LibObjT>;
- using _ThisCommonPacket = CommonPacket<LibObjT>;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
-
- using _StructureField = typename std::conditional<std::is_const<LibObjT>::value,
- ConstStructureField, StructureField>::type;
+ using _Stream = internal::DepStream<LibObjT>;
+ using _StructureField = internal::DepStructField<LibObjT>;
public:
- using Shared = internal::SharedObj<_ThisCommonPacket, LibObjT, internal::PacketRefFuncs>;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+ using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
- explicit CommonPacket(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ explicit CommonPacket(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonPacket(const CommonPacket<OtherLibObjT>& packet) noexcept : _ThisBorrowedObj {packet}
+ CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
{
}
template <typename OtherLibObjT>
- _ThisCommonPacket& operator=(const CommonPacket<OtherLibObjT>& packet) noexcept
+ CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
{
- _ThisBorrowedObj::operator=(packet);
+ _ThisBorrowedObject::operator=(packet);
return *this;
}
- CommonStream<const bt_stream> stream() const noexcept;
- _Stream stream() noexcept;
-
- nonstd::optional<ConstStructureField> contextField() const noexcept
+ CommonPacket<const bt_packet> asConst() const noexcept
{
- const auto libObjPtr = _ConstSpec::contextField(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return CommonPacket<const bt_packet> {*this};
}
- nonstd::optional<_StructureField> contextField() noexcept
- {
- const auto libObjPtr = _Spec::contextField(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
+ _Stream stream() const noexcept;
- return nonstd::nullopt;
+ OptionalBorrowedObject<_StructureField> contextField() const noexcept
+ {
+ return _Spec::contextField(this->libObjPtr());
}
Shared shared() const noexcept
{
- return Shared {*this};
+ return Shared::createWithRef(*this);
}
};
using Packet = CommonPacket<bt_packet>;
using ConstPacket = CommonPacket<const bt_packet>;
-template <typename LibObjT>
-nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
-{
- const auto libObjPtr = _ConstSpec::packet(this->_libObjPtr());
+namespace internal {
- if (libObjPtr) {
- return ConstPacket {libObjPtr};
- }
+struct PacketTypeDescr
+{
+ using Const = ConstPacket;
+ using NonConst = Packet;
+};
- return nonstd::nullopt;
-}
+template <>
+struct TypeDescr<Packet> : public PacketTypeDescr
+{
+};
-template <typename LibObjT>
-nonstd::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() noexcept
+template <>
+struct TypeDescr<ConstPacket> : public PacketTypeDescr
{
- const auto libObjPtr = _Spec::packet(this->_libObjPtr());
+};
- if (libObjPtr) {
- return _Packet {libObjPtr};
- }
+} /* namespace internal */
- return nonstd::nullopt;
+template <typename LibObjT>
+OptionalBorrowedObject<typename CommonEvent<LibObjT>::_Packet>
+CommonEvent<LibObjT>::packet() const noexcept
+{
+ return _Spec::packet(this->libObjPtr());
}
namespace internal {
struct StreamRefFuncs final
{
- static void get(const bt_stream * const libObjPtr)
+ static void get(const bt_stream * const libObjPtr) noexcept
{
bt_stream_get_ref(libObjPtr);
}
- static void put(const bt_stream * const libObjPtr)
+ static void put(const bt_stream * const libObjPtr) noexcept
{
bt_stream_put_ref(libObjPtr);
}
template <typename LibObjT>
struct CommonStreamSpec;
-// Functions specific to mutable streams
+/* Functions specific to mutable streams */
template <>
struct CommonStreamSpec<bt_stream> final
{
}
};
-// Functions specific to constant streams
+/* Functions specific to constant streams */
template <>
struct CommonStreamSpec<const bt_stream> final
{
}
};
-} // namespace internal
+} /* namespace internal */
template <typename LibObjT>
-class CommonStream final : public internal::BorrowedObj<LibObjT>
+class CommonStream final : public BorrowedObject<LibObjT>
{
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonStreamSpec<const bt_stream>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _Spec = internal::CommonStreamSpec<LibObjT>;
- using _ThisCommonStream = CommonStream<LibObjT>;
-
- using _Trace =
- typename std::conditional<std::is_const<LibObjT>::value, CommonTrace<const bt_trace>,
- CommonTrace<bt_trace>>::type;
+ using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
public:
- using Shared = internal::SharedObj<_ThisCommonStream, LibObjT, internal::StreamRefFuncs>;
-
- using Class = typename std::conditional<std::is_const<LibObjT>::value,
- CommonStreamClass<const bt_stream_class>,
- CommonStreamClass<bt_stream_class>>::type;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+ using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
+ CommonStreamClass<const bt_stream_class>>;
- explicit CommonStream(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ explicit CommonStream(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonStream(const CommonStream<OtherLibObjT>& stream) noexcept : _ThisBorrowedObj {stream}
+ CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObject {stream}
{
}
template <typename OtherLibObjT>
- _ThisCommonStream& operator=(const CommonStream<OtherLibObjT>& stream) noexcept
+ CommonStream operator=(const CommonStream<OtherLibObjT> stream) noexcept
{
- _ThisBorrowedObj::operator=(stream);
+ _ThisBorrowedObject::operator=(stream);
return *this;
}
- Packet::Shared createPacket()
+ CommonStream<const bt_stream> asConst() const noexcept
+ {
+ return CommonStream<const bt_stream> {*this};
+ }
+
+ Packet::Shared createPacket() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
- const auto libObjPtr = bt_packet_create(this->_libObjPtr());
+ const auto libObjPtr = bt_packet_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return Packet::Shared {Packet {libObjPtr}};
+ return Packet::Shared::createWithoutRef(libObjPtr);
}
- CommonStreamClass<const bt_stream_class> cls() const noexcept;
- Class cls() noexcept;
- CommonTrace<const bt_trace> trace() const noexcept;
- _Trace trace() noexcept;
+ Class cls() const noexcept;
+ _Trace trace() const noexcept;
std::uint64_t id() const noexcept
{
- return bt_stream_get_id(this->_libObjPtr());
+ return bt_stream_get_id(this->libObjPtr());
}
- void name(const char * const name)
+ CommonStream name(const bt2c::CStringView name) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
- const auto status = bt_stream_set_name(this->_libObjPtr(), name);
+ const auto status = bt_stream_set_name(this->libObjPtr(), name);
if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void name(const std::string& name)
- {
- this->name(name.data());
+ return *this;
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ bt2c::CStringView name() const noexcept
{
- const auto name = bt_stream_get_name(this->_libObjPtr());
-
- if (name) {
- return name;
- }
-
- return nonstd::nullopt;
+ return bt_stream_get_name(this->libObjPtr());
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ CommonStream userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
-
- bt_stream_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
- }
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
{
- return Shared {*this};
+ return Shared::createWithRef(*this);
}
};
using Stream = CommonStream<bt_stream>;
using ConstStream = CommonStream<const bt_stream>;
-template <typename LibObjT>
-ConstStream CommonEvent<LibObjT>::stream() const noexcept
+namespace internal {
+
+struct StreamTypeDescr
{
- return ConstStream {_ConstSpec::stream(this->_libObjPtr())};
-}
+ using Const = ConstStream;
+ using NonConst = Stream;
+};
-template <typename LibObjT>
-typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() noexcept
+template <>
+struct TypeDescr<Stream> : public StreamTypeDescr
{
- return _Stream {_Spec::stream(this->_libObjPtr())};
-}
+};
+
+template <>
+struct TypeDescr<ConstStream> : public StreamTypeDescr
+{
+};
+
+} /* namespace internal */
template <typename LibObjT>
-ConstStream CommonPacket<LibObjT>::stream() const noexcept
+typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
{
- return ConstStream {_ConstSpec::stream(this->_libObjPtr())};
+ return _Stream {_Spec::stream(this->libObjPtr())};
}
template <typename LibObjT>
-typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() noexcept
+typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
{
- return _Stream {_Spec::stream(this->_libObjPtr())};
+ return _Stream {_Spec::stream(this->libObjPtr())};
}
namespace internal {
struct TraceRefFuncs final
{
- static void get(const bt_trace * const libObjPtr)
+ static void get(const bt_trace * const libObjPtr) noexcept
{
bt_trace_get_ref(libObjPtr);
}
- static void put(const bt_trace * const libObjPtr)
+ static void put(const bt_trace * const libObjPtr) noexcept
{
bt_trace_put_ref(libObjPtr);
}
template <typename LibObjT>
struct CommonTraceSpec;
-// Functions specific to mutable traces
+/* Functions specific to mutable traces */
template <>
struct CommonTraceSpec<bt_trace> final
{
}
};
-// Functions specific to constant traces
+/* Functions specific to constant traces */
template <>
struct CommonTraceSpec<const bt_trace> final
{
}
};
-} // namespace internal
+} /* namespace internal */
template <typename LibObjT>
-class CommonTrace final : public internal::BorrowedObj<LibObjT>
+class CommonTrace final : public BorrowedObject<LibObjT>
{
- // Allow instantiate() to call `trace._libObjPtr()`
- friend class CommonStreamClass<bt_stream_class>;
-
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonTraceSpec<const bt_trace>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _Spec = internal::CommonTraceSpec<LibObjT>;
- using _ThisCommonTrace = CommonTrace<LibObjT>;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
+ using _Stream = internal::DepStream<LibObjT>;
public:
- using Shared = internal::SharedObj<_ThisCommonTrace, LibObjT, internal::TraceRefFuncs>;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+ using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
- using Class = typename std::conditional<std::is_const<LibObjT>::value,
- CommonTraceClass<const bt_trace_class>,
- CommonTraceClass<bt_trace_class>>::type;
-
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using Class = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
+ CommonTraceClass<const bt_trace_class>>;
struct ConstEnvironmentEntry
{
- bpstd::string_view name;
+ bt2c::CStringView name;
ConstValue value;
};
- explicit CommonTrace(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ explicit CommonTrace(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonTrace(const CommonTrace<OtherLibObjT>& trace) noexcept : _ThisBorrowedObj {trace}
+ CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObject {trace}
{
}
template <typename OtherLibObjT>
- _ThisCommonTrace& operator=(const CommonTrace<OtherLibObjT>& trace) noexcept
+ CommonTrace operator=(const CommonTrace<OtherLibObjT> trace) noexcept
{
- _ThisBorrowedObj::operator=(trace);
+ _ThisBorrowedObject::operator=(trace);
return *this;
}
- CommonTraceClass<const bt_trace_class> cls() const noexcept;
- Class cls() noexcept;
+ CommonTrace<const bt_trace> asConst() const noexcept
+ {
+ return CommonTrace<const bt_trace> {*this};
+ }
+
+ Class cls() const noexcept;
- void name(const char * const name)
+ CommonTrace name(const bt2c::CStringView name) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
- const auto status = bt_trace_set_name(this->_libObjPtr(), name);
+ const auto status = bt_trace_set_name(this->libObjPtr(), name);
if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void name(const std::string& name)
- {
- this->name(name.data());
+ return *this;
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ bt2c::CStringView name() const noexcept
{
- const auto name = bt_trace_get_name(this->_libObjPtr());
-
- if (name) {
- return name;
- }
-
- return nonstd::nullopt;
+ return bt_trace_get_name(this->libObjPtr());
}
- void uuid(const std::uint8_t * const uuid) noexcept
+ CommonTrace uuid(const bt2c::UuidView& uuid) const noexcept
{
- bt_trace_set_uuid(this->_libObjPtr(), uuid);
+ bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
+ return *this;
}
- nonstd::optional<bt2_common::UuidView> uuid() const noexcept
+ bt2s::optional<bt2c::UuidView> uuid() const noexcept
{
- const auto uuid = bt_trace_get_uuid(this->_libObjPtr());
+ const auto uuid = bt_trace_get_uuid(this->libObjPtr());
if (uuid) {
- return bt2_common::UuidView {uuid};
+ return bt2c::UuidView {uuid};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- std::uint64_t size() const noexcept
+ std::uint64_t length() const noexcept
{
- return bt_trace_get_stream_count(this->_libObjPtr());
+ return bt_trace_get_stream_count(this->libObjPtr());
}
- ConstStream operator[](const std::uint64_t index) const noexcept
+ _Stream operator[](const std::uint64_t index) const noexcept
{
- return ConstStream {_ConstSpec::streamByIndex(this->_libObjPtr(), index)};
+ return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
}
- _Stream operator[](const std::uint64_t index) noexcept
+ OptionalBorrowedObject<_Stream> streamById(const std::uint64_t id) const noexcept
{
- return _Stream {_Spec::streamByIndex(this->_libObjPtr(), index)};
+ return _Spec::streamById(this->libObjPtr(), id);
}
- nonstd::optional<ConstStream> streamById(const std::uint64_t id) const noexcept
+ CommonTrace environmentEntry(const bt2c::CStringView name, const std::int64_t val) const
{
- const auto libObjPtr = _ConstSpec::streamById(this->_libObjPtr(), id);
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
- if (libObjPtr) {
- return ConstStream {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_Stream> streamById(const std::uint64_t id) noexcept
- {
- const auto libObjPtr = _Spec::streamById(this->_libObjPtr(), id);
-
- if (libObjPtr) {
- return _Stream {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- void environmentEntry(const char * const name, const std::int64_t val)
- {
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
-
- const auto status = bt_trace_set_environment_entry_integer(this->_libObjPtr(), name, val);
+ const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void environmentEntry(const std::string& name, const std::int64_t val)
- {
- this->environmentEntry(name.data(), val);
+ return *this;
}
- void environmentEntry(const char * const name, const char * const val)
+ CommonTrace environmentEntry(const bt2c::CStringView name, const bt2c::CStringView val) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
- const auto status = bt_trace_set_environment_entry_string(this->_libObjPtr(), name, val);
+ const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void environmentEntry(const std::string& name, const char * const val)
- {
- this->environmentEntry(name.data(), val);
- }
-
- void environmentEntry(const char * const name, const std::string& val)
- {
- this->environmentEntry(name, val.data());
- }
-
- void environmentEntry(const std::string& name, const std::string& val)
- {
- this->environmentEntry(name.data(), val.data());
+ return *this;
}
std::uint64_t environmentSize() const noexcept
{
- return bt_trace_get_environment_entry_count(this->_libObjPtr());
+ return bt_trace_get_environment_entry_count(this->libObjPtr());
}
ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
const char *name;
const bt_value *libObjPtr;
- bt_trace_borrow_environment_entry_by_index_const(this->_libObjPtr(), index, &name,
+ bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
&libObjPtr);
return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
}
- nonstd::optional<ConstValue> environmentEntry(const char * const name) const noexcept
- {
- const auto libObjPtr =
- bt_trace_borrow_environment_entry_value_by_name_const(this->_libObjPtr(), name);
-
- if (libObjPtr) {
- return ConstValue {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<ConstValue> environmentEntry(const std::string& name) const noexcept
+ OptionalBorrowedObject<ConstValue> environmentEntry(const bt2c::CStringView name) const noexcept
{
- return this->environmentEntry(name.data());
+ return bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ CommonTrace userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
- bt_trace_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
- }
-
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
{
- return Shared {*this};
+ return Shared::createWithRef(*this);
}
};
using Trace = CommonTrace<bt_trace>;
using ConstTrace = CommonTrace<const bt_trace>;
-template <typename LibObjT>
-ConstTrace CommonStream<LibObjT>::trace() const noexcept
+namespace internal {
+
+struct TraceTypeDescr
{
- return ConstTrace {_ConstSpec::trace(this->_libObjPtr())};
-}
+ using Const = ConstTrace;
+ using NonConst = Trace;
+};
+
+template <>
+struct TypeDescr<Trace> : public TraceTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstTrace> : public TraceTypeDescr
+{
+};
+
+} /* namespace internal */
template <typename LibObjT>
-typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() noexcept
+typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
{
- return _Trace {_Spec::trace(this->_libObjPtr())};
+ return _Trace {_Spec::trace(this->libObjPtr())};
}
namespace internal {
struct EventClassRefFuncs final
{
- static void get(const bt_event_class * const libObjPtr)
+ static void get(const bt_event_class * const libObjPtr) noexcept
{
bt_event_class_get_ref(libObjPtr);
}
- static void put(const bt_event_class * const libObjPtr)
+ static void put(const bt_event_class * const libObjPtr) noexcept
{
bt_event_class_put_ref(libObjPtr);
}
template <typename LibObjT>
struct CommonEventClassSpec;
-// Functions specific to mutable event classes
+/* Functions specific to mutable event classes */
template <>
struct CommonEventClassSpec<bt_event_class> final
{
}
};
-// Functions specific to constant event classes
+/* Functions specific to constant event classes */
template <>
struct CommonEventClassSpec<const bt_event_class> final
{
}
};
-} // namespace internal
+template <typename LibObjT>
+using DepStructFc = DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
+
+} /* namespace internal */
template <typename LibObjT>
-class CommonEventClass final : public internal::BorrowedObj<LibObjT>
+class CommonEventClass final : public BorrowedObject<LibObjT>
{
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonEventClassSpec<const bt_event_class>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _Spec = internal::CommonEventClassSpec<LibObjT>;
- using _ThisCommonEventClass = CommonEventClass<LibObjT>;
+ using _StructureFieldClass = internal::DepStructFc<LibObjT>;
- using _StreamClass = typename std::conditional<std::is_const<LibObjT>::value,
- CommonStreamClass<const bt_stream_class>,
- CommonStreamClass<bt_stream_class>>::type;
-
- using _StructureFieldClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClass,
- StructureFieldClass>::type;
+ using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
+ CommonStreamClass<const bt_stream_class>>;
public:
- using Shared =
- internal::SharedObj<_ThisCommonEventClass, LibObjT, internal::EventClassRefFuncs>;
-
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+ using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
enum class LogLevel
{
EMERGENCY = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
ALERT = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
CRITICAL = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
- ERROR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
+ ERR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
WARNING = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
NOTICE = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
INFO = BT_EVENT_CLASS_LOG_LEVEL_INFO,
DEBUG_SYSTEM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
DEBUG_PROGRAM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
- DEBUG_PROCESS = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
+ DEBUG_PROC = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
DEBUG_MODULE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
DEBUG_UNIT = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
DEBUG_FUNCTION = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
};
- explicit CommonEventClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ explicit CommonEventClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonEventClass(const CommonEventClass<OtherLibObjT>& eventClass) noexcept :
- _ThisBorrowedObj {eventClass}
+ CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
+ _ThisBorrowedObject {eventClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonEventClass& operator=(const CommonEventClass<OtherLibObjT>& eventClass) noexcept
+ CommonEventClass operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
{
- _ThisBorrowedObj::operator=(eventClass);
+ _ThisBorrowedObject::operator=(eventClass);
return *this;
}
- CommonStreamClass<const bt_stream_class> streamClass() const noexcept;
- _StreamClass streamClass() noexcept;
+ CommonEventClass<const bt_event_class> asConst() const noexcept
+ {
+ return CommonEventClass<const bt_event_class> {*this};
+ }
+
+ _StreamClass streamClass() const noexcept;
std::uint64_t id() const noexcept
{
- return bt_event_class_get_id(this->_libObjPtr());
+ return bt_event_class_get_id(this->libObjPtr());
}
- void name(const char * const name)
+ CommonEventClass name(const bt2c::CStringView name) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
- const auto status = bt_event_class_set_name(this->_libObjPtr(), name);
+ const auto status = bt_event_class_set_name(this->libObjPtr(), name);
if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void name(const std::string& name)
- {
- this->name(name.data());
+ return *this;
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ bt2c::CStringView name() const noexcept
{
- const auto name = bt_event_class_get_name(this->_libObjPtr());
-
- if (name) {
- return name;
- }
-
- return nonstd::nullopt;
+ return bt_event_class_get_name(this->libObjPtr());
}
- void logLevel(const LogLevel logLevel) noexcept
+ CommonEventClass logLevel(const LogLevel logLevel) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
- bt_event_class_set_log_level(this->_libObjPtr(),
+ bt_event_class_set_log_level(this->libObjPtr(),
static_cast<bt_event_class_log_level>(logLevel));
+ return *this;
}
- nonstd::optional<LogLevel> logLevel() const noexcept
+ bt2s::optional<LogLevel> logLevel() const noexcept
{
bt_event_class_log_level libLogLevel;
- const auto avail = bt_event_class_get_log_level(this->_libObjPtr(), &libLogLevel);
- if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
+ if (bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel)) {
return static_cast<LogLevel>(libLogLevel);
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- void emfUri(const char * const emfUri)
+ CommonEventClass emfUri(const bt2c::CStringView emfUri) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
- const auto status = bt_event_class_set_emf_uri(this->_libObjPtr(), emfUri);
+ const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void emfUri(const std::string& emfUri)
- {
- this->emfUri(emfUri.data());
+ return *this;
}
- nonstd::optional<bpstd::string_view> emfUri() const noexcept
+ bt2c::CStringView emfUri() const noexcept
{
- const auto emfUri = bt_event_class_get_emf_uri(this->_libObjPtr());
-
- if (emfUri) {
- return emfUri;
- }
-
- return nonstd::nullopt;
+ return bt_event_class_get_emf_uri(this->libObjPtr());
}
- void payloadFieldClass(const StructureFieldClass& fc)
+ CommonEventClass payloadFieldClass(const StructureFieldClass fc) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
const auto status =
- bt_event_class_set_payload_field_class(this->_libObjPtr(), fc._libObjPtr());
+ bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
- }
- }
-
- nonstd::optional<ConstStructureFieldClass> payloadFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::payloadFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
+ throw MemoryError {};
}
- return nonstd::nullopt;
+ return *this;
}
- nonstd::optional<_StructureFieldClass> payloadFieldClass() noexcept
+ OptionalBorrowedObject<_StructureFieldClass> payloadFieldClass() const noexcept
{
- const auto libObjPtr = _Spec::payloadFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::payloadFieldClass(this->libObjPtr());
}
- void specificContextFieldClass(const StructureFieldClass& fc)
+ CommonEventClass specificContextFieldClass(const StructureFieldClass fc) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
const auto status =
- bt_event_class_set_specificContext_field_class(this->_libObjPtr(), fc._libObjPtr());
+ bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
- }
- }
-
- nonstd::optional<ConstStructureFieldClass> specificContextFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::specificContextFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
+ throw MemoryError {};
}
- return nonstd::nullopt;
+ return *this;
}
- nonstd::optional<_StructureFieldClass> specificContextFieldClass() noexcept
+ OptionalBorrowedObject<_StructureFieldClass> specificContextFieldClass() const noexcept
{
- const auto libObjPtr = _Spec::specificContextFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::specificContextFieldClass(this->libObjPtr());
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ CommonEventClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
-
- bt_event_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
- }
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
{
- return Shared {*this};
+ return Shared::createWithRef(*this);
}
};
using EventClass = CommonEventClass<bt_event_class>;
using ConstEventClass = CommonEventClass<const bt_event_class>;
-template <typename LibObjT>
-ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
+namespace internal {
+
+struct EventClassTypeDescr
{
- return ConstEventClass {_ConstSpec::cls(this->_libObjPtr())};
-}
+ using Const = ConstEventClass;
+ using NonConst = EventClass;
+};
+
+template <>
+struct TypeDescr<EventClass> : public EventClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
+{
+};
+
+} /* namespace internal */
template <typename LibObjT>
-typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() noexcept
+typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
{
- return Class {_Spec::cls(this->_libObjPtr())};
+ return Class {_Spec::cls(this->libObjPtr())};
}
namespace internal {
struct StreamClassRefFuncs final
{
- static void get(const bt_stream_class * const libObjPtr)
+ static void get(const bt_stream_class * const libObjPtr) noexcept
{
bt_stream_class_get_ref(libObjPtr);
}
- static void put(const bt_stream_class * const libObjPtr)
+ static void put(const bt_stream_class * const libObjPtr) noexcept
{
bt_stream_class_put_ref(libObjPtr);
}
template <typename LibObjT>
struct CommonStreamClassSpec;
-// Functions specific to mutable stream classes
+/* Functions specific to mutable stream classes */
template <>
struct CommonStreamClassSpec<bt_stream_class> final
{
}
};
-// Functions specific to constant stream classes
+/* Functions specific to constant stream classes */
template <>
struct CommonStreamClassSpec<const bt_stream_class> final
{
}
};
-} // namespace internal
+} /* namespace internal */
template <typename LibObjT>
-class CommonStreamClass final : public internal::BorrowedObj<LibObjT>
+class CommonStreamClass final : public BorrowedObject<LibObjT>
{
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonStreamClassSpec<const bt_stream_class>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _Spec = internal::CommonStreamClassSpec<LibObjT>;
- using _ThisCommonStreamClass = CommonStreamClass<LibObjT>;
-
- using _TraceClass = typename std::conditional<std::is_const<LibObjT>::value,
- CommonTraceClass<const bt_trace_class>,
- CommonTraceClass<bt_trace_class>>::type;
+ using _StructureFieldClass = internal::DepStructFc<LibObjT>;
- using _EventClass = typename std::conditional<std::is_const<LibObjT>::value,
- CommonEventClass<const bt_event_class>,
- CommonEventClass<bt_event_class>>::type;
+ using _TraceClass = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
+ CommonTraceClass<const bt_trace_class>>;
- using _StructureFieldClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClass,
- StructureFieldClass>::type;
+ using _EventClass = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
+ CommonEventClass<const bt_event_class>>;
- using _ClockClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstClockClass, ClockClass>::type;
+ using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
public:
- using Shared =
- internal::SharedObj<_ThisCommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
-
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+ using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
- explicit CommonStreamClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ explicit CommonStreamClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonStreamClass(const CommonStreamClass<OtherLibObjT>& streamClass) noexcept :
- _ThisBorrowedObj {streamClass}
+ CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
+ _ThisBorrowedObject {streamClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonStreamClass& operator=(const CommonStreamClass<OtherLibObjT>& streamClass) noexcept
+ CommonStreamClass operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
{
- _ThisBorrowedObj::operator=(streamClass);
+ _ThisBorrowedObject::operator=(streamClass);
return *this;
}
- Stream::Shared instantiate(const Trace& trace)
+ CommonStreamClass<const bt_stream_class> asConst() const noexcept
+ {
+ return CommonStreamClass<const bt_stream_class> {*this};
+ }
+
+ Stream::Shared instantiate(const Trace trace) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- const auto libObjPtr = bt_stream_create(this->_libObjPtr(), trace._libObjPtr());
+ const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return Stream::Shared {Stream {libObjPtr}};
+ return Stream::Shared::createWithoutRef(libObjPtr);
}
- Stream::Shared instantiate(const Trace& trace, const std::uint64_t id)
+ Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- const auto libObjPtr = bt_stream_create_with_id(this->_libObjPtr(), trace._libObjPtr(), id);
+ const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
internal::validateCreatedObjPtr(libObjPtr);
- return Stream::Shared {Stream {libObjPtr}};
+ return Stream::Shared::createWithoutRef(libObjPtr);
}
- EventClass::Shared createEventClass()
+ EventClass::Shared createEventClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- const auto libObjPtr = bt_event_class_create(this->_libObjPtr());
+ const auto libObjPtr = bt_event_class_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return EventClass::Shared {EventClass {libObjPtr}};
+ return EventClass::Shared::createWithoutRef(libObjPtr);
}
- EventClass::Shared createEventClass(const std::uint64_t id)
+ EventClass::Shared createEventClass(const std::uint64_t id) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- const auto libObjPtr = bt_event_class_create_with_id(this->_libObjPtr(), id);
+ const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
internal::validateCreatedObjPtr(libObjPtr);
- return EventClass::Shared {EventClass {libObjPtr}};
+ return EventClass::Shared::createWithoutRef(libObjPtr);
}
- CommonTraceClass<const bt_trace_class> traceClass() const noexcept;
- _TraceClass traceClass() noexcept;
+ _TraceClass traceClass() const noexcept;
std::uint64_t id() const noexcept
{
- return bt_stream_class_get_id(this->_libObjPtr());
+ return bt_stream_class_get_id(this->libObjPtr());
}
- void name(const char * const name)
+ CommonStreamClass name(const bt2c::CStringView name) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- const auto status = bt_stream_class_set_name(this->_libObjPtr(), name);
+ const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ throw MemoryError {};
}
- }
- void name(const std::string& name)
- {
- this->name(name.data());
+ return *this;
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ bt2c::CStringView name() const noexcept
{
- const auto name = bt_stream_class_get_name(this->_libObjPtr());
-
- if (name) {
- return name;
- }
-
- return nonstd::nullopt;
+ return bt_stream_class_get_name(this->libObjPtr());
}
- void assignsAutomaticEventClassId(const bool val) noexcept
+ CommonStreamClass assignsAutomaticEventClassId(const bool val) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- bt_stream_class_set_assigns_automatic_event_class_id(this->_libObjPtr(),
+ bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
static_cast<bt_bool>(val));
+ return *this;
}
bool assignsAutomaticEventClassId() const noexcept
{
return static_cast<bool>(
- bt_stream_class_assigns_automatic_event_class_id(this->_libObjPtr()));
+ bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
}
- void assignsAutomaticStreamId(const bool val) noexcept
+ CommonStreamClass assignsAutomaticStreamId(const bool val) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- bt_stream_class_set_assigns_automatic_stream_id(this->_libObjPtr(),
+ bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
static_cast<bt_bool>(val));
+ return *this;
}
bool assignsAutomaticStreamId() const noexcept
{
- return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->_libObjPtr()));
+ return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
}
- void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
- const bool withEndDefaultClkSnapshot) noexcept
+ CommonStreamClass supportsPackets(const bool supportsPackets,
+ const bool withBeginningDefaultClkSnapshot,
+ const bool withEndDefaultClkSnapshot) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- bt_stream_class_set_supports_packets(this->_libObjPtr(),
+ bt_stream_class_set_supports_packets(this->libObjPtr(),
static_cast<bt_bool>(supportsPackets),
static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
static_cast<bt_bool>(withEndDefaultClkSnapshot));
+ return *this;
}
bool supportsPackets() const noexcept
{
- return static_cast<bool>(bt_stream_class_supports_packets(this->_libObjPtr()));
+ return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
}
bool packetsHaveBeginningClockSnapshot() const noexcept
{
return static_cast<bool>(
- bt_stream_class_packets_have_beginning_default_clock_snapshot(this->_libObjPtr()));
+ bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
}
bool packetsHaveEndClockSnapshot() const noexcept
{
return static_cast<bool>(
- bt_stream_class_packets_have_end_default_clock_snapshot(this->_libObjPtr()));
+ bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
}
- void supportsDiscardedEvents(const bool supportsDiscardedEvents,
- const bool withDefaultClkSnapshots) noexcept
+ CommonStreamClass supportsDiscardedEvents(const bool supportsDiscardedEvents,
+ const bool withDefaultClkSnapshots) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
bt_stream_class_set_supports_discarded_events(
- this->_libObjPtr(), static_cast<bt_bool>(supportsPackets),
+ this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedEvents),
static_cast<bt_bool>(withDefaultClkSnapshots));
+ return *this;
}
bool supportsDiscardedEvents() const noexcept
{
- return static_cast<bool>(bt_stream_class_supports_discarded_events(this->_libObjPtr()));
+ return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
}
bool discardedEventsHaveDefaultClockSnapshots() const noexcept
{
return static_cast<bool>(
- bt_stream_class_discarded_events_have_default_clock_snapshots(this->_libObjPtr()));
+ bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
}
- void supportsDiscardedPackets(const bool supportsDiscardedPackets,
- const bool withDefaultClkSnapshots) noexcept
+ CommonStreamClass supportsDiscardedPackets(const bool supportsDiscardedPackets,
+ const bool withDefaultClkSnapshots) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
bt_stream_class_set_supports_discarded_packets(
- this->_libObjPtr(), static_cast<bt_bool>(supportsPackets),
+ this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedPackets),
static_cast<bt_bool>(withDefaultClkSnapshots));
+ return *this;
}
bool supportsDiscardedPackets() const noexcept
{
- return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->_libObjPtr()));
+ return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
}
bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
{
return static_cast<bool>(
- bt_stream_class_discarded_packets_have_default_clock_snapshots(this->_libObjPtr()));
+ bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
}
- void defaultClockClass(const ClockClass& clkCls)
+ CommonStreamClass defaultClockClass(const ClockClass clkCls) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
const auto status =
- bt_stream_class_set_default_clock_class(this->_libObjPtr(), clkCls._libObjPtr());
+ bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
+ return *this;
}
- nonstd::optional<ConstClockClass> defaultClockClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::defaultClockClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstClockClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_ClockClass> defaultClockClass() noexcept
- {
- const auto libObjPtr = _Spec::defaultClockClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return _ClockClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- std::uint64_t size() const noexcept
- {
- return bt_stream_class_get_event_class_count(this->_libObjPtr());
- }
-
- ConstEventClass operator[](const std::uint64_t index) const noexcept
+ OptionalBorrowedObject<_ClockClass> defaultClockClass() const noexcept
{
- return ConstEventClass {_ConstSpec::eventClassByIndex(this->_libObjPtr(), index)};
+ return _Spec::defaultClockClass(this->libObjPtr());
}
- _EventClass operator[](const std::uint64_t index) noexcept
+ std::uint64_t length() const noexcept
{
- return _EventClass {_Spec::eventClassByIndex(this->_libObjPtr(), index)};
+ return bt_stream_class_get_event_class_count(this->libObjPtr());
}
- nonstd::optional<ConstEventClass> eventClassById(const std::uint64_t id) const noexcept
+ _EventClass operator[](const std::uint64_t index) const noexcept
{
- const auto libObjPtr = _ConstSpec::eventClassById(this->_libObjPtr(), id);
-
- if (libObjPtr) {
- return ConstEventClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) noexcept
+ OptionalBorrowedObject<_EventClass> eventClassById(const std::uint64_t id) const noexcept
{
- const auto libObjPtr = _Spec::eventClassById(this->_libObjPtr(), id);
-
- if (libObjPtr) {
- return _EventClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::eventClassById(this->libObjPtr(), id);
}
- void packetContextFieldClass(const StructureFieldClass& fc)
+ CommonStreamClass packetContextFieldClass(const StructureFieldClass fc) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
const auto status =
- bt_stream_class_set_payload_field_class(this->_libObjPtr(), fc._libObjPtr());
+ bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
- if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
+ if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
+ throw MemoryError {};
}
- }
- nonstd::optional<ConstStructureFieldClass> packetContextFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return *this;
}
- nonstd::optional<_StructureFieldClass> packetContextFieldClass() noexcept
+ OptionalBorrowedObject<_StructureFieldClass> packetContextFieldClass() const noexcept
{
- const auto libObjPtr = _Spec::packetContextFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::packetContextFieldClass(this->libObjPtr());
}
- void eventCommonContextFieldClass(const StructureFieldClass& fc)
+ CommonStreamClass eventCommonContextFieldClass(const StructureFieldClass fc) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
const auto status =
- bt_stream_class_set_specificContext_field_class(this->_libObjPtr(), fc._libObjPtr());
-
- if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
- throw LibMemoryError {};
- }
- }
-
- nonstd::optional<ConstStructureFieldClass> eventCommonContextFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::eventCommonContextFieldClass(this->_libObjPtr());
+ bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
+ if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
+ throw MemoryError {};
}
- return nonstd::nullopt;
+ return *this;
}
- nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() noexcept
+ OptionalBorrowedObject<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
{
- const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->_libObjPtr());
-
- if (libObjPtr) {
- return _StructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::eventCommonContextFieldClass(this->libObjPtr());
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ CommonStreamClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamClass`.");
- bt_stream_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
- }
-
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
{
- return Shared {*this};
+ return Shared::createWithRef(*this);
}
};
using StreamClass = CommonStreamClass<bt_stream_class>;
using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
-template <typename LibObjT>
-ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
+namespace internal {
+
+struct StreamClassTypeDescr
{
- return ConstStreamClass {_ConstSpec::streamClass(this->_libObjPtr())};
-}
+ using Const = ConstStreamClass;
+ using NonConst = StreamClass;
+};
-template <typename LibObjT>
-typename CommonEventClass<LibObjT>::_StreamClass CommonEventClass<LibObjT>::streamClass() noexcept
+template <>
+struct TypeDescr<StreamClass> : public StreamClassTypeDescr
{
- return _StreamClass {_Spec::streamClass(this->_libObjPtr())};
-}
+};
+
+template <>
+struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
+{
+};
+
+} /* namespace internal */
template <typename LibObjT>
-ConstStreamClass CommonStream<LibObjT>::cls() const noexcept
+typename CommonEventClass<LibObjT>::_StreamClass
+CommonEventClass<LibObjT>::streamClass() const noexcept
{
- return ConstStreamClass {_ConstSpec::cls(this->_libObjPtr())};
+ return _StreamClass {_Spec::streamClass(this->libObjPtr())};
}
template <typename LibObjT>
-typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() noexcept
+typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
{
- return Class {_Spec::cls(this->_libObjPtr())};
+ return Class {_Spec::cls(this->libObjPtr())};
}
namespace internal {
struct TraceClassRefFuncs final
{
- static void get(const bt_trace_class * const libObjPtr)
+ static void get(const bt_trace_class * const libObjPtr) noexcept
{
bt_trace_class_get_ref(libObjPtr);
}
- static void put(const bt_trace_class * const libObjPtr)
+ static void put(const bt_trace_class * const libObjPtr) noexcept
{
bt_trace_class_put_ref(libObjPtr);
}
template <typename LibObjT>
struct CommonTraceClassSpec;
-// Functions specific to mutable stream classes
+/* Functions specific to mutable stream classes */
template <>
struct CommonTraceClassSpec<bt_trace_class> final
{
}
};
-// Functions specific to constant stream classes
+/* Functions specific to constant stream classes */
template <>
struct CommonTraceClassSpec<const bt_trace_class> final
{
}
};
-} // namespace internal
+} /* namespace internal */
template <typename LibObjT>
-class CommonTraceClass final : public internal::BorrowedObj<LibObjT>
+class CommonTraceClass final : public BorrowedObject<LibObjT>
{
private:
- using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
- using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonTraceClassSpec<const bt_trace_class>;
+ using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
+
using _Spec = internal::CommonTraceClassSpec<LibObjT>;
- using _ThisCommonTraceClass = CommonTraceClass<LibObjT>;
- using _StreamClass = typename std::conditional<std::is_const<LibObjT>::value,
- CommonStreamClass<const bt_stream_class>,
- CommonStreamClass<bt_stream_class>>::type;
+ using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
+ CommonStreamClass<const bt_stream_class>>;
public:
- using Shared =
- internal::SharedObj<_ThisCommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+ using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
-
- explicit CommonTraceClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+ explicit CommonTraceClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonTraceClass(const CommonTraceClass<OtherLibObjT>& traceClass) noexcept :
- _ThisBorrowedObj {traceClass}
+ CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
+ _ThisBorrowedObject {traceClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonTraceClass& operator=(const CommonTraceClass<OtherLibObjT>& traceClass) noexcept
+ CommonTraceClass operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
{
- _ThisBorrowedObj::operator=(traceClass);
+ _ThisBorrowedObject::operator=(traceClass);
return *this;
}
- Trace::Shared instantiate(const Trace& trace)
+ CommonTraceClass<const bt_trace_class> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonTraceClass<const bt_trace_class> {*this};
+ }
- const auto libObjPtr = bt_trace_create(this->_libObjPtr());
+ Trace::Shared instantiate() const
+ {
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
+
+ const auto libObjPtr = bt_trace_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return Trace::Shared {Trace {libObjPtr}};
+ return Trace::Shared::createWithoutRef(libObjPtr);
}
- StreamClass::Shared createStreamClass()
+ StreamClass::Shared createStreamClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_stream_class_create(this->_libObjPtr());
+ const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return StreamClass::Shared {StreamClass {libObjPtr}};
+ return StreamClass::Shared::createWithoutRef(libObjPtr);
}
- StreamClass::Shared createStreamClass(const std::uint64_t id)
+ StreamClass::Shared createStreamClass(const std::uint64_t id) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_stream_class_create_with_id(this->_libObjPtr(), id);
+ const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
internal::validateCreatedObjPtr(libObjPtr);
- return StreamClass::Shared {StreamClass {libObjPtr}};
+ return StreamClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createBoolFieldClass()
+ FieldClass::Shared createBoolFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_bool_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return FieldClass::Shared {FieldClass {libObjPtr}};
+ return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length)
+ BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_bit_array_create(this->_libObjPtr(), length);
+ const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
internal::validateCreatedObjPtr(libObjPtr);
- return BitArrayFieldClass::Shared {BitArrayFieldClass {libObjPtr}};
+ return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
}
- IntegerFieldClass::Shared createUnsignedIntegerFieldClass()
+ IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_integer_unsigned_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return IntegerFieldClass::Shared {IntegerFieldClass {libObjPtr}};
+ return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
}
- IntegerFieldClass::Shared createSignedIntegerFieldClass()
+ IntegerFieldClass::Shared createSignedIntegerFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_integer_signed_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return IntegerFieldClass::Shared {IntegerFieldClass {libObjPtr}};
+ return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
}
- UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass()
+ UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return UnsignedEnumerationFieldClass::Shared {UnsignedEnumerationFieldClass {libObjPtr}};
+ return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
}
- SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass()
+ SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_enumeration_signed_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return SignedEnumerationFieldClass::Shared {SignedEnumerationFieldClass {libObjPtr}};
+ return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createSinglePrecisionRealFieldClass()
+ FieldClass::Shared createSinglePrecisionRealFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_real_single_precision_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return FieldClass::Shared {FieldClass {libObjPtr}};
+ return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createDoublePrecisionRealFieldClass()
+ FieldClass::Shared createDoublePrecisionRealFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_real_double_precision_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return FieldClass::Shared {FieldClass {libObjPtr}};
+ return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createStringFieldClass()
+ FieldClass::Shared createStringFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_string_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return FieldClass::Shared {FieldClass {libObjPtr}};
+ return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass& elementFieldClass,
- const std::uint64_t length)
+ StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
+ const std::uint64_t length) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_array_static_create(
- this->_libObjPtr(), elementFieldClass._libObjPtr(), length);
+ this->libObjPtr(), elementFieldClass.libObjPtr(), length);
internal::validateCreatedObjPtr(libObjPtr);
- return StaticArrayFieldClass::Shared {StaticArrayFieldClass {libObjPtr}};
+ return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
}
- ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass& elementFieldClass)
+ ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_array_dynamic_create(
- this->_libObjPtr(), elementFieldClass._libObjPtr(), nullptr);
+ this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
internal::validateCreatedObjPtr(libObjPtr);
- return ArrayFieldClass::Shared {ArrayFieldClass {libObjPtr}};
+ return ArrayFieldClass::Shared::createWithoutRef(libObjPtr);
}
DynamicArrayWithLengthFieldClass::Shared
- createDynamicArrayFieldClass(const FieldClass& elementFieldClass,
- const IntegerFieldClass& lengthFieldClass)
+ createDynamicArrayFieldClass(const FieldClass elementFieldClass,
+ const IntegerFieldClass lengthFieldClass) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_array_dynamic_create(
- this->_libObjPtr(), elementFieldClass._libObjPtr(), lengthFieldClass._libObjPtr());
+ this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return DynamicArrayWithLengthFieldClass::Shared {
- DynamicArrayWithLengthFieldClass {libObjPtr}};
+ return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
}
- StructureFieldClass::Shared createStructureFieldClass(const std::uint64_t length)
+ StructureFieldClass::Shared createStructureFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_structure_create(this->_libObjPtr(), length);
+ const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return StructureFieldClass::Shared {StructureFieldClass {libObjPtr}};
+ return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
}
- OptionFieldClass::Shared createOptionFieldClass(const FieldClass& optionalFieldClass)
+ OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_option_without_selector_create(
- this->_libObjPtr(), optionalFieldClass._libObjPtr());
+ this->libObjPtr(), optionalFieldClass.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return OptionFieldClass::Shared {OptionFieldClass {libObjPtr}};
+ return OptionFieldClass::Shared::createWithoutRef(libObjPtr);
}
OptionWithBoolSelectorFieldClass::Shared
- createOptionWithBoolSelectorFieldClass(const FieldClass& optionalFieldClass,
- const FieldClass& selectorFieldClass)
+ createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
+ const FieldClass selectorFieldClass) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
- this->_libObjPtr(), optionalFieldClass._libObjPtr(), selectorFieldClass._libObjPtr());
+ this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return OptionWithBoolSelectorFieldClass::Shared {
- OptionWithBoolSelectorFieldClass {libObjPtr}};
+ return OptionWithBoolSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
}
OptionWithUnsignedIntegerSelectorFieldClass::Shared
- createOptionWithUnsignedIntegerSelectorFieldClass(const FieldClass& optionalFieldClass,
- const IntegerFieldClass& selectorFieldClass,
- const ConstUnsignedIntegerRangeSet& ranges)
+ createOptionWithUnsignedIntegerSelectorFieldClass(
+ const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
+ const ConstUnsignedIntegerRangeSet ranges) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
- this->_libObjPtr(), optionalFieldClass._libObjPtr(), selectorFieldClass._libObjPtr(),
- ranges._libObjPtr());
+ this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
+ ranges.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return OptionWithUnsignedIntegerSelectorFieldClass::Shared {
- OptionWithUnsignedIntegerSelectorFieldClass {libObjPtr}};
+ return OptionWithUnsignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
}
OptionWithSignedIntegerSelectorFieldClass::Shared
- createOptionWithSignedIntegerSelectorFieldClass(const FieldClass& optionalFieldClass,
- const IntegerFieldClass& selectorFieldClass,
- const ConstSignedIntegerRangeSet& ranges)
+ createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
+ const IntegerFieldClass selectorFieldClass,
+ const ConstSignedIntegerRangeSet ranges) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
- this->_libObjPtr(), optionalFieldClass._libObjPtr(), selectorFieldClass._libObjPtr(),
- ranges._libObjPtr());
+ this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
+ ranges.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return OptionWithSignedIntegerSelectorFieldClass::Shared {
- OptionWithSignedIntegerSelectorFieldClass {libObjPtr}};
+ return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
}
- VariantWithoutSelectorFieldClass::Shared createVariantFieldClass()
+ VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- const auto libObjPtr = bt_field_class_variant_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
internal::validateCreatedObjPtr(libObjPtr);
- return VariantWithoutSelectorFieldClass::Shared {
- VariantWithoutSelectorFieldClass {libObjPtr}};
+ return VariantWithoutSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
}
VariantWithUnsignedIntegerSelectorFieldClass::Shared
- createVariantWithUnsignedIntegerSelectorFieldClass(const IntegerFieldClass& selectorFieldClass)
+ createVariantWithUnsignedIntegerSelectorFieldClass(
+ const IntegerFieldClass selectorFieldClass) const
{
- return VariantWithUnsignedIntegerSelectorFieldClass::Shared {
- VariantWithUnsignedIntegerSelectorFieldClass {
- this->_createVariantWithIntegerSelectorFieldClass(selectorFieldClass)}};
+ return this->_createVariantWithIntegerSelectorFieldClass<
+ VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
}
VariantWithSignedIntegerSelectorFieldClass::Shared
- createVariantWithSignedIntegerSelectorFieldClass(const IntegerFieldClass& selectorFieldClass)
+ createVariantWithSignedIntegerSelectorFieldClass(
+ const IntegerFieldClass selectorFieldClass) const
{
- return VariantWithSignedIntegerSelectorFieldClass::Shared {
- VariantWithSignedIntegerSelectorFieldClass {
- this->_createVariantWithIntegerSelectorFieldClass(selectorFieldClass)}};
+ return this->_createVariantWithIntegerSelectorFieldClass<
+ VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
}
- void assignsAutomaticStreamClassId(const bool val) noexcept
+ CommonTraceClass assignsAutomaticStreamClassId(const bool val) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- bt_trace_class_set_assigns_automatic_stream_class_id(this->_libObjPtr(),
+ bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
static_cast<bt_bool>(val));
+ return *this;
}
bool assignsAutomaticStreamClassId() const noexcept
{
return static_cast<bool>(
- bt_trace_class_assigns_automatic_stream_class_id(this->_libObjPtr()));
+ bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
}
- std::uint64_t size() const noexcept
+ std::uint64_t length() const noexcept
{
- return bt_trace_class_get_stream_class_count(this->_libObjPtr());
+ return bt_trace_class_get_stream_class_count(this->libObjPtr());
}
- ConstStreamClass operator[](const std::uint64_t index) const noexcept
+ _StreamClass operator[](const std::uint64_t index) const noexcept
{
- return ConstStreamClass {_ConstSpec::streamClassByIndex(this->_libObjPtr(), index)};
+ return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
}
- _StreamClass operator[](const std::uint64_t index) noexcept
+ OptionalBorrowedObject<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
{
- return _StreamClass {_Spec::streamClassByIndex(this->_libObjPtr(), index)};
- }
-
- nonstd::optional<ConstStreamClass> streamClassById(const std::uint64_t id) const noexcept
- {
- const auto libObjPtr = _ConstSpec::streamClassById(this->_libObjPtr(), id);
-
- if (libObjPtr) {
- return ConstStreamClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) noexcept
- {
- const auto libObjPtr = _Spec::streamClassById(this->_libObjPtr(), id);
-
- if (libObjPtr) {
- return _StreamClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::streamClassById(this->libObjPtr(), id);
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ CommonTraceClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
- bt_trace_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
- }
-
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
{
- return Shared {*this};
+ return Shared::createWithRef(*this);
}
private:
- bt_field_class *
- _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass& selectorFieldClass)
+ template <typename ObjT>
+ typename ObjT::Shared
+ _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
const auto libObjPtr =
- bt_field_class_variant_create(this->_libObjPtr(), selectorFieldClass._libObjPtr());
+ bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
- return libObjPtr;
+ return ObjT::Shared::createWithoutRef(libObjPtr);
}
};
using TraceClass = CommonTraceClass<bt_trace_class>;
using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
-template <typename LibObjT>
-ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
+namespace internal {
+
+struct TraceClassTypeDescr
{
- return ConstTraceClass {_ConstSpec::traceClass(this->_libObjPtr())};
-}
+ using Const = ConstTraceClass;
+ using NonConst = TraceClass;
+};
-template <typename LibObjT>
-typename CommonStreamClass<LibObjT>::_TraceClass CommonStreamClass<LibObjT>::traceClass() noexcept
+template <>
+struct TypeDescr<TraceClass> : public TraceClassTypeDescr
{
- return _TraceClass {_Spec::traceClass(this->_libObjPtr())};
-}
+};
+
+template <>
+struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
+{
+};
+
+} /* namespace internal */
template <typename LibObjT>
-ConstTraceClass CommonTrace<LibObjT>::cls() const noexcept
+typename CommonStreamClass<LibObjT>::_TraceClass
+CommonStreamClass<LibObjT>::traceClass() const noexcept
{
- return ConstTraceClass {_ConstSpec::cls(this->_libObjPtr())};
+ return _TraceClass {_Spec::traceClass(this->libObjPtr())};
}
template <typename LibObjT>
-typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() noexcept
+typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
{
- return Class {_Spec::cls(this->_libObjPtr())};
+ return Class {_Spec::cls(this->libObjPtr())};
}
-} // namespace bt2
+} /* namespace bt2 */
-#endif // BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
+#endif /* BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP */