return *this;
}
+ CommonClockClass<const bt_clock_class> asConst() const noexcept
+ {
+ return CommonClockClass<const bt_clock_class> {*this};
+ }
+
void frequency(const std::uint64_t frequency) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonFieldClass<const bt_field_class> {*this};
+ }
+
FieldClassType type() const noexcept
{
return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
return *this;
}
+ CommonBitArrayFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonBitArrayFieldClass<const bt_field_class> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_field_class_bit_array_get_length(this->libObjPtr());
return *this;
}
+ CommonIntegerFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonIntegerFieldClass<const bt_field_class> {*this};
+ }
+
void fieldValueRange(const std::uint64_t n) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonBaseEnumerationFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonBaseEnumerationFieldClass<const bt_field_class> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
return *this;
}
+ CommonStructureFieldClassMember<const bt_field_class_structure_member> asConst() const noexcept
+ {
+ return CommonStructureFieldClassMember<const bt_field_class_structure_member> {*this};
+ }
+
bpstd::string_view name() const noexcept
{
return bt_field_class_structure_member_get_name(this->libObjPtr());
return *this;
}
+ CommonStructureFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonStructureFieldClass<const bt_field_class> {*this};
+ }
+
void appendMember(const char * const name, const FieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonArrayFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonArrayFieldClass<const bt_field_class> {*this};
+ }
+
_FieldClass elementFieldClass() const noexcept
{
return _FieldClass {
return *this;
}
+ CommonStaticArrayFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonStaticArrayFieldClass<const bt_field_class> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_field_class_array_static_get_length(this->libObjPtr());
return *this;
}
+ CommonDynamicArrayWithLengthFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonDynamicArrayWithLengthFieldClass<const bt_field_class> {*this};
+ }
+
ConstFieldPath lengthFieldPath() const noexcept
{
return ConstFieldPath {
return *this;
}
+ CommonOptionFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonOptionFieldClass<const bt_field_class> {*this};
+ }
+
_FieldClass fieldClass() const noexcept
{
return _FieldClass {
return *this;
}
+ CommonOptionWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonOptionWithSelectorFieldClass<const bt_field_class> {*this};
+ }
+
ConstFieldPath selectorFieldPath() const noexcept
{
return ConstFieldPath {
return *this;
}
+ CommonOptionWithBoolSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonOptionWithBoolSelectorFieldClass<const bt_field_class> {*this};
+ }
+
bool selectorIsReversed() const noexcept
{
return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
return *this;
}
+ CommonVariantFieldClassOption<const bt_field_class_variant_option> asConst() const noexcept
+ {
+ return CommonVariantFieldClassOption<const bt_field_class_variant_option> {*this};
+ }
+
nonstd::optional<bpstd::string_view> name() const noexcept
{
const auto name = bt_field_class_variant_option_get_name(this->libObjPtr());
return *this;
}
+ CommonVariantFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonVariantFieldClass<const bt_field_class> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_field_class_variant_get_option_count(this->libObjPtr());
return *this;
}
+ CommonVariantWithoutSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonVariantWithoutSelectorFieldClass<const bt_field_class> {*this};
+ }
+
void appendOption(const char * const name, const FieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonVariantWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonVariantWithSelectorFieldClass<const bt_field_class> {*this};
+ }
+
ConstFieldPath selectorFieldPath() const noexcept
{
return ConstFieldPath {
return *this;
}
+ CommonField<const bt_field> asConst() const noexcept
+ {
+ return CommonField<const bt_field> {*this};
+ }
+
FieldClassType classType() const noexcept
{
return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
return *this;
}
+ CommonBoolField<const bt_field> asConst() const noexcept
+ {
+ return CommonBoolField<const bt_field> {*this};
+ }
+
CommonBoolField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonBitArrayField<const bt_field> asConst() const noexcept
+ {
+ return CommonBitArrayField<const bt_field> {*this};
+ }
+
ConstBitArrayFieldClass cls() const noexcept
{
return ConstBitArrayFieldClass {
return *this;
}
+ CommonUnsignedIntegerField<const bt_field> asConst() const noexcept
+ {
+ return CommonUnsignedIntegerField<const bt_field> {*this};
+ }
+
Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
return *this;
}
+ CommonSignedIntegerField<const bt_field> asConst() const noexcept
+ {
+ return CommonSignedIntegerField<const bt_field> {*this};
+ }
+
Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
return *this;
}
+ CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
+ {
+ return CommonUnsignedEnumerationField<const bt_field> {*this};
+ }
+
using CommonUnsignedIntegerField<LibObjT>::operator=;
Class cls() const noexcept
return *this;
}
+ CommonSignedEnumerationField<const bt_field> asConst() const noexcept
+ {
+ return CommonSignedEnumerationField<const bt_field> {*this};
+ }
+
using CommonSignedIntegerField<LibObjT>::operator=;
Class cls() const noexcept
return *this;
}
+ CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
+ {
+ return CommonSinglePrecisionRealField<const bt_field> {*this};
+ }
+
CommonSinglePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
+ {
+ return CommonDoublePrecisionRealField<const bt_field> {*this};
+ }
+
CommonDoublePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonStringField<const bt_field> asConst() const noexcept
+ {
+ return CommonStringField<const bt_field> {*this};
+ }
+
CommonStringField<LibObjT> operator=(const char * const val) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonStructureField<const bt_field> asConst() const noexcept
+ {
+ return CommonStructureField<const bt_field> {*this};
+ }
+
Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
return *this;
}
+ CommonArrayField<const bt_field> asConst() const noexcept
+ {
+ return CommonArrayField<const bt_field> {*this};
+ }
+
Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
return *this;
}
+ CommonDynamicArrayField<const bt_field> asConst() const noexcept
+ {
+ return CommonDynamicArrayField<const bt_field> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return _ThisCommonArrayField::length();
return *this;
}
+ CommonOptionField<const bt_field> asConst() const noexcept
+ {
+ return CommonOptionField<const bt_field> {*this};
+ }
+
Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
return *this;
}
+ CommonVariantField<const bt_field> asConst() const noexcept
+ {
+ return CommonVariantField<const bt_field> {*this};
+ }
+
Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
return *this;
}
+ _ConstLibObjT asConst() const noexcept
+ {
+ return _ConstLibObjT {*this};
+ }
+
template <typename OtherLibObjT>
bool operator==(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
{
return *this;
}
+ CommonMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonMessage<const bt_message> {*this};
+ }
+
MessageType type() const noexcept
{
return static_cast<MessageType>(bt_message_get_type(this->libObjPtr()));
return *this;
}
+ CommonStreamBeginningMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonStreamBeginningMessage<const bt_message> {*this};
+ }
+
_Stream stream() const noexcept
{
return _Stream {
return *this;
}
+ CommonStreamEndMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonStreamEndMessage<const bt_message> {*this};
+ }
+
_Stream stream() const noexcept
{
return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->libObjPtr())};
return *this;
}
+ CommonPacketBeginningMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonPacketBeginningMessage<const bt_message> {*this};
+ }
+
_Packet packet() const noexcept
{
return _Packet {
return *this;
}
+ CommonPacketEndMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonPacketEndMessage<const bt_message> {*this};
+ }
+
_Packet packet() const noexcept
{
return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->libObjPtr())};
return *this;
}
+ CommonEventMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonEventMessage<const bt_message> {*this};
+ }
+
_Event event() const noexcept
{
return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
return *this;
}
+ CommonDiscardedEventsMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonDiscardedEventsMessage<const bt_message> {*this};
+ }
+
_Stream stream() const noexcept
{
return _Stream {
return *this;
}
+ CommonDiscardedPacketsMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonDiscardedPacketsMessage<const bt_message> {*this};
+ }
+
_Stream stream() const noexcept
{
return _Stream {
return *this;
}
+ CommonMessageIteratorInactivityMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonMessageIteratorInactivityMessage<const bt_message> {*this};
+ }
+
ConstClockSnapshot clockSnapshot() const noexcept
{
const auto libObjPtr =
return *this;
}
+ CommonEvent<const bt_event> asConst() const noexcept
+ {
+ return CommonEvent<const bt_event> {*this};
+ }
+
Class cls() const noexcept;
_Stream stream() const noexcept;
nonstd::optional<_Packet> packet() const noexcept;
return *this;
}
+ CommonPacket<const bt_packet> asConst() const noexcept
+ {
+ return CommonPacket<const bt_packet> {*this};
+ }
+
_Stream stream() const noexcept;
nonstd::optional<_StructureField> contextField() const noexcept
return *this;
}
+ 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`.");
return *this;
}
+ CommonTrace<const bt_trace> asConst() const noexcept
+ {
+ return CommonTrace<const bt_trace> {*this};
+ }
+
Class cls() const noexcept;
void name(const char * const name) const
return *this;
}
+ 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 *this;
}
+ 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`.");
return *this;
}
+ CommonTraceClass<const bt_trace_class> asConst() const noexcept
+ {
+ return CommonTraceClass<const bt_trace_class> {*this};
+ }
+
Trace::Shared instantiate() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonValue<const bt_value> asConst() const noexcept
+ {
+ return CommonValue<const bt_value> {*this};
+ }
+
ValueType type() const noexcept
{
return static_cast<ValueType>(bt_value_get_type(this->libObjPtr()));
return *this;
}
+ CommonNullValue<const bt_value> asConst() const noexcept
+ {
+ return CommonNullValue<const bt_value> {*this};
+ }
+
Shared shared() const noexcept
{
return Shared::createWithRef(*this);
return *this;
}
+ CommonBoolValue<const bt_value> asConst() const noexcept
+ {
+ return CommonBoolValue<const bt_value> {*this};
+ }
+
CommonBoolValue<LibObjT> operator=(const Value rawVal) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonUnsignedIntegerValue<const bt_value> asConst() const noexcept
+ {
+ return CommonUnsignedIntegerValue<const bt_value> {*this};
+ }
+
CommonUnsignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
{
bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
return *this;
}
+ CommonSignedIntegerValue<const bt_value> asConst() const noexcept
+ {
+ return CommonSignedIntegerValue<const bt_value> {*this};
+ }
+
CommonSignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonRealValue<const bt_value> asConst() const noexcept
+ {
+ return CommonRealValue<const bt_value> {*this};
+ }
+
CommonRealValue<LibObjT> operator=(const Value rawVal) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonStringValue<const bt_value> asConst() const noexcept
+ {
+ return CommonStringValue<const bt_value> {*this};
+ }
+
CommonStringValue<LibObjT> operator=(const char * const rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
+ CommonArrayValue<const bt_value> asConst() const noexcept
+ {
+ return CommonArrayValue<const bt_value> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_value_array_get_length(this->libObjPtr());
return *this;
}
+ CommonMapValue<const bt_value> asConst() const noexcept
+ {
+ return CommonMapValue<const bt_value> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_value_map_get_size(this->libObjPtr());