#include <babeltrace2/babeltrace.h>
-#include "cpp-common/optional.hpp"
+#include "common/macros.h"
+#include "cpp-common/bt2c/c-string-view.hpp"
+#include "cpp-common/bt2s/optional.hpp"
#include "borrowed-object.hpp"
#include "clock-class.hpp"
#include "field-class.hpp"
#include "field.hpp"
#include "internal/utils.hpp"
+#include "optional-borrowed-object.hpp"
#include "shared-object.hpp"
#include "value.hpp"
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::CommonEventSpec<LibObjT>;
using _Packet = internal::DepPacket<LibObjT>;
using _Stream = internal::DepStream<LibObjT>;
using _StructureField = internal::DepStructField<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+
using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
CommonEventClass<const bt_event_class>>;
- explicit CommonEvent(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonEvent(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
Class cls() const noexcept;
_Stream stream() const noexcept;
- nonstd::optional<_Packet> packet() const noexcept;
+ OptionalBorrowedObject<_Packet> packet() const noexcept;
- nonstd::optional<_StructureField> payloadField() const noexcept
+ OptionalBorrowedObject<_StructureField> payloadField() const noexcept
{
- const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::payloadField(this->libObjPtr());
}
- nonstd::optional<_StructureField> specificContextField() const noexcept
+ OptionalBorrowedObject<_StructureField> specificContextField() const noexcept
{
- const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::specificContextField(this->libObjPtr());
}
- nonstd::optional<_StructureField> commonContextField() const 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());
}
};
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::CommonPacketSpec<LibObjT>;
using _Stream = internal::DepStream<LibObjT>;
using _StructureField = internal::DepStructField<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
- explicit CommonPacket(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonPacket(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
_Stream stream() const noexcept;
- nonstd::optional<_StructureField> contextField() const noexcept
+ OptionalBorrowedObject<_StructureField> contextField() const noexcept
{
- const auto libObjPtr = _Spec::contextField(this->libObjPtr());
-
- if (libObjPtr) {
- return _StructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::contextField(this->libObjPtr());
}
Shared shared() const noexcept
} /* namespace internal */
template <typename LibObjT>
-nonstd::optional<typename CommonEvent<LibObjT>::_Packet>
+OptionalBorrowedObject<typename CommonEvent<LibObjT>::_Packet>
CommonEvent<LibObjT>::packet() const noexcept
{
- const auto libObjPtr = _Spec::packet(this->libObjPtr());
-
- if (libObjPtr) {
- return _Packet {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::packet(this->libObjPtr());
}
namespace internal {
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::CommonStreamSpec<LibObjT>;
using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
CommonStreamClass<const bt_stream_class>>;
- explicit CommonStream(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonStream(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
return bt_stream_get_id(this->libObjPtr());
}
- void name(const char * const name) const
+ CommonStream name(const bt2c::CStringView name) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void name(const std::string& name) const
- {
- this->name(name.data());
+ return *this;
}
- const char *name() const noexcept
+ bt2c::CStringView name() const noexcept
{
return bt_stream_get_name(this->libObjPtr());
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
+ CommonStream userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
UserAttributes userAttributes() const noexcept
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::CommonTraceSpec<LibObjT>;
using _Stream = internal::DepStream<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
struct ConstEnvironmentEntry
{
- const char *name;
+ bt2c::CStringView name;
ConstValue value;
};
- explicit CommonTrace(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonTrace(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
Class cls() const noexcept;
- void name(const char * const name) const
+ CommonTrace name(const bt2c::CStringView name) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void name(const std::string& name) const
- {
- this->name(name.data());
+ return *this;
}
- const char *name() const noexcept
+ bt2c::CStringView name() const noexcept
{
return bt_trace_get_name(this->libObjPtr());
}
- void uuid(const bt2c::UuidView& uuid) const noexcept
+ CommonTrace uuid(const bt2c::UuidView& uuid) const noexcept
{
bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
+ return *this;
}
- nonstd::optional<bt2c::UuidView> uuid() const noexcept
+ bt2s::optional<bt2c::UuidView> uuid() const noexcept
{
const auto uuid = bt_trace_get_uuid(this->libObjPtr());
return bt2c::UuidView {uuid};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
std::uint64_t length() const noexcept
return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<_Stream> streamById(const std::uint64_t id) const noexcept
+ OptionalBorrowedObject<_Stream> streamById(const std::uint64_t id) const noexcept
{
- const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
-
- if (libObjPtr) {
- return _Stream {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::streamById(this->libObjPtr(), id);
}
- void environmentEntry(const char * const name, const std::int64_t val) const
+ CommonTrace environmentEntry(const bt2c::CStringView name, const std::int64_t val) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void environmentEntry(const std::string& name, const std::int64_t val) const
- {
- this->environmentEntry(name.data(), val);
+ return *this;
}
- void environmentEntry(const char * const name, const char * const val) const
+ CommonTrace environmentEntry(const bt2c::CStringView name, const bt2c::CStringView val) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void environmentEntry(const std::string& name, const char * const val) const
- {
- this->environmentEntry(name.data(), val);
- }
-
- void environmentEntry(const char * const name, const std::string& val) const
- {
- this->environmentEntry(name, val.data());
- }
-
- void environmentEntry(const std::string& name, const std::string& val) const
- {
- this->environmentEntry(name.data(), val.data());
+ return *this;
}
std::uint64_t environmentSize() const noexcept
return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
}
- nonstd::optional<ConstValue> environmentEntry(const char * const name) const noexcept
+ OptionalBorrowedObject<ConstValue> environmentEntry(const bt2c::CStringView 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
- {
- 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) const noexcept
+ CommonTrace userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
UserAttributes userAttributes() const noexcept
} /* namespace internal */
+/* Avoid `-Wshadow` error on GCC, conflicting with `bt2::Error` */
+BT_DIAG_PUSH
+BT_DIAG_IGNORE_SHADOW
+
+enum class EventClassLogLevel
+{
+ 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,
+ Warning = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
+ Notice = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
+ Info = BT_EVENT_CLASS_LOG_LEVEL_INFO,
+ DebugSystem = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
+ DebugProgram = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
+ DebugProcess = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
+ DebugModule = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
+ DebugUnit = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
+ DebugFunction = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
+ DebugLine = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
+ Debug = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
+};
+
+BT_DIAG_POP
+
template <typename LibObjT>
class CommonEventClass final : public BorrowedObject<LibObjT>
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::CommonEventClassSpec<LibObjT>;
using _StructureFieldClass = internal::DepStructFc<LibObjT>;
CommonStreamClass<const bt_stream_class>>;
public:
+ 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,
- 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_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_LINE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
- DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
- };
-
- explicit CommonEventClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonEventClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
return bt_event_class_get_id(this->libObjPtr());
}
- void name(const char * const name) const
+ CommonEventClass name(const bt2c::CStringView name) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void name(const std::string& name) const
- {
- this->name(name.data());
+ return *this;
}
- const char *name() const noexcept
+ bt2c::CStringView name() const noexcept
{
return bt_event_class_get_name(this->libObjPtr());
}
- void logLevel(const LogLevel logLevel) const noexcept
+ CommonEventClass logLevel(const EventClassLogLevel logLevel) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
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<EventClassLogLevel> 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) {
- return static_cast<LogLevel>(libLogLevel);
+ if (bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel)) {
+ return static_cast<EventClassLogLevel>(libLogLevel);
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- void emfUri(const char * const emfUri) const
+ CommonEventClass emfUri(const bt2c::CStringView emfUri) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void emfUri(const std::string& emfUri) const
- {
- this->emfUri(emfUri.data());
+ return *this;
}
- const char *emfUri() const noexcept
+ bt2c::CStringView emfUri() const noexcept
{
return bt_event_class_get_emf_uri(this->libObjPtr());
}
- void payloadFieldClass(const StructureFieldClass fc) const
+ CommonEventClass payloadFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
+
+ return *this;
}
- nonstd::optional<_StructureFieldClass> payloadFieldClass() const 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) const
+ CommonEventClass specificContextFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
+
+ return *this;
}
- nonstd::optional<_StructureFieldClass> specificContextFieldClass() const 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) const noexcept
+ CommonEventClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
UserAttributes userAttributes() const noexcept
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::CommonStreamClassSpec<LibObjT>;
using _StructureFieldClass = internal::DepStructFc<LibObjT>;
using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
- explicit CommonStreamClass(const _LibObjPtr libObjPtr) noexcept :
- _ThisBorrowedObject {libObjPtr}
+ explicit CommonStreamClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
return bt_stream_class_get_id(this->libObjPtr());
}
- void name(const char * const name) const
+ CommonStreamClass name(const bt2c::CStringView name) const
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
- }
- void name(const std::string& name) const
- {
- this->name(name.data());
+ return *this;
}
- const char *name() const noexcept
+ bt2c::CStringView name() const noexcept
{
return bt_stream_class_get_name(this->libObjPtr());
}
- void assignsAutomaticEventClassId(const bool val) const noexcept
+ CommonStreamClass assignsAutomaticEventClassId(const bool val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
static_cast<bt_bool>(val));
+ return *this;
}
bool assignsAutomaticEventClassId() const noexcept
bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
}
- void assignsAutomaticStreamId(const bool val) const noexcept
+ CommonStreamClass assignsAutomaticStreamId(const bool val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
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()));
}
- void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
- const bool withEndDefaultClkSnapshot) const noexcept
+ CommonStreamClass supportsPackets(const bool supportsPackets,
+ const bool withBeginningDefaultClkSnapshot,
+ const bool withEndDefaultClkSnapshot) const noexcept
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
static_cast<bt_bool>(supportsPackets),
static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
static_cast<bt_bool>(withEndDefaultClkSnapshot));
+ return *this;
}
bool supportsPackets() const noexcept
bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
}
- void supportsDiscardedEvents(const bool supportsDiscardedEvents,
- const bool withDefaultClkSnapshots) const noexcept
+ CommonStreamClass supportsDiscardedEvents(const bool supportsDiscardedEvents,
+ const bool withDefaultClkSnapshots) const noexcept
{
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>(supportsDiscardedEvents),
static_cast<bt_bool>(withDefaultClkSnapshots));
+ return *this;
}
bool supportsDiscardedEvents() const noexcept
bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
}
- void supportsDiscardedPackets(const bool supportsDiscardedPackets,
- const bool withDefaultClkSnapshots) const noexcept
+ CommonStreamClass supportsDiscardedPackets(const bool supportsDiscardedPackets,
+ const bool withDefaultClkSnapshots) const noexcept
{
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>(supportsDiscardedPackets),
static_cast<bt_bool>(withDefaultClkSnapshots));
+ return *this;
}
bool supportsDiscardedPackets() const noexcept
bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
}
- void defaultClockClass(const ClockClass clkCls) const
+ CommonStreamClass defaultClockClass(const ClockClass clkCls) const
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
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<_ClockClass> defaultClockClass() const noexcept
+ OptionalBorrowedObject<_ClockClass> defaultClockClass() const noexcept
{
- const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
-
- if (libObjPtr) {
- return _ClockClass {libObjPtr};
- }
-
- return nonstd::nullopt;
+ return _Spec::defaultClockClass(this->libObjPtr());
}
std::uint64_t length() const noexcept
return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) const 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) const
+ CommonStreamClass packetContextFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
+
+ return *this;
}
- nonstd::optional<_StructureFieldClass> packetContextFieldClass() const 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) const
+ CommonStreamClass eventCommonContextFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
+
+ return *this;
}
- nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() const 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) const noexcept
+ CommonStreamClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStreamClass`.");
bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
UserAttributes userAttributes() const noexcept
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
+
using _Spec = internal::CommonTraceClassSpec<LibObjT>;
using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
CommonStreamClass<const bt_stream_class>>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
- explicit CommonTraceClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonTraceClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
}
- void assignsAutomaticStreamClassId(const bool val) const noexcept
+ CommonTraceClass assignsAutomaticStreamClassId(const bool val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
static_cast<bt_bool>(val));
+ return *this;
}
bool assignsAutomaticStreamClassId() const noexcept
return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
+ OptionalBorrowedObject<_StreamClass> streamClassById(const std::uint64_t id) const 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) const noexcept
+ CommonTraceClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
+ return *this;
}
UserAttributes userAttributes() const noexcept
projects / babeltrace.git / blobdiff