{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_clock_class_set_frequency(this->_libObjPtr(), frequency);
+ bt_clock_class_set_frequency(this->libObjPtr(), frequency);
}
std::uint64_t frequency() const noexcept
{
- return bt_clock_class_get_frequency(this->_libObjPtr());
+ return bt_clock_class_get_frequency(this->libObjPtr());
}
void offset(const ClockClassOffset& offset) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_clock_class_set_offset(this->_libObjPtr(), offset.seconds(), offset.cycles());
+ bt_clock_class_set_offset(this->libObjPtr(), offset.seconds(), offset.cycles());
}
ClockClassOffset offset() const noexcept
std::int64_t seconds;
std::uint64_t cycles;
- bt_clock_class_get_offset(this->_libObjPtr(), &seconds, &cycles);
+ bt_clock_class_get_offset(this->libObjPtr(), &seconds, &cycles);
return ClockClassOffset {seconds, cycles};
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_clock_class_set_precision(this->_libObjPtr(), precision);
+ bt_clock_class_set_precision(this->libObjPtr(), precision);
}
std::uint64_t precision() const noexcept
{
- return bt_clock_class_get_precision(this->_libObjPtr());
+ return bt_clock_class_get_precision(this->libObjPtr());
}
void originIsUnixEpoch(const bool originIsUnixEpoch) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_clock_class_set_origin_is_unix_epoch(this->_libObjPtr(),
+ bt_clock_class_set_origin_is_unix_epoch(this->libObjPtr(),
static_cast<bt_bool>(originIsUnixEpoch));
}
bool originIsUnixEpoch() const noexcept
{
- return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->_libObjPtr()));
+ return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->libObjPtr()));
}
void name(const char * const name)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_clock_class_set_name(this->_libObjPtr(), name);
+ const auto status = bt_clock_class_set_name(this->libObjPtr(), name);
if (status == BT_CLOCK_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
nonstd::optional<bpstd::string_view> name() const noexcept
{
- const auto name = bt_clock_class_get_name(this->_libObjPtr());
+ const auto name = bt_clock_class_get_name(this->libObjPtr());
if (name) {
return name;
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_clock_class_set_description(this->_libObjPtr(), description);
+ const auto status = bt_clock_class_set_description(this->libObjPtr(), description);
if (status == BT_CLOCK_CLASS_SET_DESCRIPTION_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
nonstd::optional<bpstd::string_view> description() const noexcept
{
- const auto description = bt_clock_class_get_description(this->_libObjPtr());
+ const auto description = bt_clock_class_get_description(this->libObjPtr());
if (description) {
return description;
void uuid(const std::uint8_t * const uuid) noexcept
{
- bt_clock_class_set_uuid(this->_libObjPtr(), uuid);
+ bt_clock_class_set_uuid(this->libObjPtr(), uuid);
}
nonstd::optional<bt2_common::UuidView> uuid() const noexcept
{
- const auto uuid = bt_clock_class_get_uuid(this->_libObjPtr());
+ const auto uuid = bt_clock_class_get_uuid(this->libObjPtr());
if (uuid) {
return bt2_common::UuidView {uuid};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_clock_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_clock_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
return ConstMapValue {internal::CommonClockClassSpec<const bt_clock_class>::userAttributes(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
return UserAttributes {
- internal::CommonClockClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
+ internal::CommonClockClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
}
std::int64_t cyclesToNsFromOrigin(const std::uint64_t value) const
{
std::int64_t nsFromOrigin;
const auto status =
- bt_clock_class_cycles_to_ns_from_origin(this->_libObjPtr(), value, &nsFromOrigin);
+ bt_clock_class_cycles_to_ns_from_origin(this->libObjPtr(), value, &nsFromOrigin);
if (status == BT_CLOCK_CLASS_CYCLES_TO_NS_FROM_ORIGIN_STATUS_OVERFLOW_ERROR) {
throw LibOverflowError {};
std::uint64_t value() const noexcept
{
- return bt_clock_snapshot_get_value(this->_libObjPtr());
+ return bt_clock_snapshot_get_value(this->libObjPtr());
}
operator std::uint64_t() const noexcept
std::int64_t nsFromOrigin() const
{
std::int64_t nsFromOrigin;
- const auto status = bt_clock_snapshot_get_ns_from_origin(this->_libObjPtr(), &nsFromOrigin);
+ const auto status = bt_clock_snapshot_get_ns_from_origin(this->libObjPtr(), &nsFromOrigin);
if (status == BT_CLOCK_SNAPSHOT_GET_NS_FROM_ORIGIN_STATUS_OVERFLOW_ERROR) {
throw LibOverflowError {};
template <typename LibObjT>
class CommonFieldClass : public internal::BorrowedObj<LibObjT>
{
- /* Allow appendMember() to call `fc._libObjPtr()` */
+ /* Allow appendMember() to call `fc.libObjPtr()` */
friend class CommonStructureFieldClass<bt_field_class>;
- /* Allow appendOption() to call `fc._libObjPtr()` */
+ /* Allow appendOption() to call `fc.libObjPtr()` */
friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
friend class CommonVariantWithIntegerSelectorFieldClass<
ConstVariantWithIntegerSelectorFieldClassOption<
const bt_field_class_variant_with_selector_field_integer_signed_option>>;
- /* Allow *FieldClass() to call `fc._libObjPtr()` */
+ /* Allow *FieldClass() to call `fc.libObjPtr()` */
friend class CommonEventClass<bt_event_class>;
friend class CommonStreamClass<bt_stream_class>;
- /* Allow create*FieldClass() to call `fc._libObjPtr()` */
+ /* Allow create*FieldClass() to call `fc.libObjPtr()` */
friend class CommonTraceClass<bt_trace_class>;
private:
FieldClassType type() const noexcept
{
- return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
+ return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
}
bool isBool() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
return UserAttributes {
- internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
+ internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
protected:
bool _libTypeIs(const bt_field_class_type type) const noexcept
{
- return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type);
+ return bt_field_class_type_is(bt_field_class_get_type(this->libObjPtr()), type);
}
};
std::uint64_t length() const noexcept
{
- return bt_field_class_bit_array_get_length(this->_libObjPtr());
+ return bt_field_class_bit_array_get_length(this->libObjPtr());
}
Shared shared() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
+ bt_field_class_integer_get_field_value_range(this->libObjPtr(), n);
}
std::uint64_t fieldValueRange() const noexcept
{
- return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
+ return bt_field_class_integer_get_field_value_range(this->libObjPtr());
}
void preferredDisplayBase(const DisplayBase base) noexcept
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_field_class_integer_set_preferred_display_base(
- this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
+ this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
}
DisplayBase preferredDisplayBase() const noexcept
{
return static_cast<DisplayBase>(
- bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
+ bt_field_class_integer_get_preferred_display_base(this->libObjPtr()));
}
Shared shared() const noexcept
RangeSet ranges() const noexcept
{
return RangeSet {
- internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
+ internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
}
bpstd::string_view label() const noexcept
{
- return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
+ return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
}
};
std::uint64_t size() const noexcept
{
- return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
+ return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
}
Shared shared() const noexcept
Mapping operator[](const std::uint64_t index) const noexcept
{
return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
nonstd::optional<Mapping> operator[](const char * const label) const noexcept
{
const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
- this->_libObjPtr(), label);
+ this->libObjPtr(), label);
if (libObjPtr) {
return Mapping {libObjPtr};
bpstd::string_view name() const noexcept
{
- return bt_field_class_structure_member_get_name(this->_libObjPtr());
+ return bt_field_class_structure_member_get_name(this->libObjPtr());
}
ConstFieldClass fieldClass() const noexcept
{
return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
- const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
+ const bt_field_class_structure_member>::fieldClass(this->libObjPtr())};
}
_FieldClass fieldClass() noexcept
{
return _FieldClass {
- internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+ internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
+ bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
std::uint64_t size() const noexcept
{
- return bt_field_class_structure_get_member_count(this->_libObjPtr());
+ return bt_field_class_structure_get_member_count(this->libObjPtr());
}
Iterator begin() const noexcept
{
return ConstStructureFieldClassMember {
internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
Member operator[](const std::uint64_t index) noexcept
{
return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
nonstd::optional<ConstStructureFieldClassMember>
{
const auto libObjPtr =
internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
- this->_libObjPtr(), name);
+ this->libObjPtr(), name);
if (libObjPtr) {
return ConstStructureFieldClassMember {libObjPtr};
nonstd::optional<Member> operator[](const char * const name) noexcept
{
- const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
- this->_libObjPtr(), name);
+ const auto libObjPtr =
+ internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
if (libObjPtr) {
return Member {libObjPtr};
{
return ConstFieldClass {
internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
_FieldClass elementFieldClass() noexcept
{
return _FieldClass {
- internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
+ internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
}
Shared shared() const noexcept
std::uint64_t length() const noexcept
{
- return bt_field_class_array_static_get_length(this->_libObjPtr());
+ return bt_field_class_array_static_get_length(this->libObjPtr());
}
Shared shared() const noexcept
{
return ConstFieldPath {
bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
Shared shared() const noexcept
{
return ConstFieldClass {
internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
_FieldClass fieldClass() noexcept
{
return _FieldClass {
- internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+ internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
Shared shared() const noexcept
{
return ConstFieldPath {
bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
Shared shared() const noexcept
bool selectorIsReversed() const noexcept
{
return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
- this->_libObjPtr());
+ this->libObjPtr());
}
Shared shared() const noexcept
RangeSet ranges() const noexcept
{
return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
Shared shared() const noexcept
bpstd::string_view name() const noexcept
{
- return bt_field_class_variant_option_get_name(this->_libObjPtr());
+ return bt_field_class_variant_option_get_name(this->libObjPtr());
}
ConstFieldClass fieldClass() const noexcept
{
return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
- const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
+ const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
}
_FieldClass fieldClass() noexcept
{
return _FieldClass {
- internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+ internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
};
ConstVariantFieldClassOption asBaseOption() const noexcept
{
- return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
+ return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
}
bpstd::string_view name() const noexcept
RangeSet ranges() const noexcept
{
- return RangeSet {_Spec::ranges(this->_libObjPtr())};
+ return RangeSet {_Spec::ranges(this->libObjPtr())};
}
};
std::uint64_t size() const noexcept
{
- return bt_field_class_variant_get_option_count(this->_libObjPtr());
+ return bt_field_class_variant_get_option_count(this->libObjPtr());
}
Iterator begin() const noexcept
{
return ConstVariantFieldClassOption {
internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
Option operator[](const std::uint64_t index) noexcept
{
return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
nonstd::optional<ConstVariantFieldClassOption>
{
const auto libObjPtr =
internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
- this->_libObjPtr(), name);
+ this->libObjPtr(), name);
if (libObjPtr) {
return ConstVariantFieldClassOption {libObjPtr};
nonstd::optional<Option> operator[](const char * const name) noexcept
{
const auto libObjPtr =
- internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
+ internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
if (libObjPtr) {
return Option {libObjPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status = bt_field_class_variant_without_selector_append_option(
- this->_libObjPtr(), name, fc._libObjPtr());
+ this->libObjPtr(), name, fc.libObjPtr());
if (status ==
BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
{
return ConstFieldPath {
bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
Shared shared() const noexcept
Option operator[](const std::uint64_t index) const noexcept
{
- return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
+ return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
}
nonstd::optional<Option> operator[](const char * const name) const noexcept
{
- const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
+ const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
if (libObjPtr) {
return Option {libObjPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
+ _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
if (status ==
BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
{
BT_ASSERT_DBG(this->isBitArray());
- return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
{
BT_ASSERT_DBG(this->isInteger());
- return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
{
BT_ASSERT_DBG(this->isEnumeration());
- return CommonBaseEnumerationFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
{
BT_ASSERT_DBG(this->isUnsignedEnumeration());
return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
- this->_libObjPtr()};
+ this->libObjPtr()};
}
template <typename LibObjT>
{
BT_ASSERT_DBG(this->isSignedEnumeration());
return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
- this->_libObjPtr()};
+ this->libObjPtr()};
}
template <typename LibObjT>
CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
{
BT_ASSERT_DBG(this->isStructure());
- return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
{
BT_ASSERT_DBG(this->isArray());
- return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
{
BT_ASSERT_DBG(this->isStaticArray());
- return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
{
BT_ASSERT_DBG(this->isDynamicArrayWithLength());
- return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
{
BT_ASSERT_DBG(this->isOption());
- return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
{
BT_ASSERT_DBG(this->isOptionWithSelector());
- return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
{
BT_ASSERT_DBG(this->isOptionWithBoolSelector());
- return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
{
BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
- this->_libObjPtr()};
+ this->libObjPtr()};
}
template <typename LibObjT>
{
BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
- this->_libObjPtr()};
+ this->libObjPtr()};
}
template <typename LibObjT>
CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
{
BT_ASSERT_DBG(this->isVariant());
- return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
{
BT_ASSERT_DBG(this->isVariantWithoutSelector());
- return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
{
BT_ASSERT_DBG(this->isVariantWithSelector());
- return CommonVariantWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+ return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
{
BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
return CommonVariantWithIntegerSelectorFieldClass<
- LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
+ LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
}
template <typename LibObjT>
{
BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
return CommonVariantWithIntegerSelectorFieldClass<
- LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
+ LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
}
} /* namespace bt2 */
private:
bt_field_path_item_type _libType() const noexcept
{
- return bt_field_path_item_get_type(this->_libObjPtr());
+ return bt_field_path_item_get_type(this->libObjPtr());
}
};
std::uint64_t index() const noexcept
{
- return bt_field_path_item_index_get_index(this->_libObjPtr());
+ return bt_field_path_item_index_get_index(this->libObjPtr());
}
};
inline ConstIndexFieldPathItem ConstFieldPathItem::asIndex() const noexcept
{
BT_ASSERT_DBG(this->isIndex());
- return ConstIndexFieldPathItem {this->_libObjPtr()};
+ return ConstIndexFieldPathItem {this->libObjPtr()};
}
namespace internal {
Scope rootScope() const noexcept
{
- return static_cast<Scope>(bt_field_path_get_root_scope(this->_libObjPtr()));
+ return static_cast<Scope>(bt_field_path_get_root_scope(this->libObjPtr()));
}
std::uint64_t size() const noexcept
{
- return bt_field_path_get_item_count(this->_libObjPtr());
+ return bt_field_path_get_item_count(this->libObjPtr());
}
ConstFieldPathItem operator[](const std::uint64_t index) const noexcept
{
return ConstFieldPathItem {
- bt_field_path_borrow_item_by_index_const(this->_libObjPtr(), index)};
+ bt_field_path_borrow_item_by_index_const(this->libObjPtr(), index)};
}
Shared shared() const noexcept
FieldClassType classType() const noexcept
{
- return static_cast<FieldClassType>(bt_field_get_class_type(this->_libObjPtr()));
+ return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
}
ConstFieldClass cls() const noexcept
{
- return ConstFieldClass {internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ return ConstFieldClass {internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
bool isBool() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_bool_set_value(this->_libObjPtr(), static_cast<bt_bool>(val));
+ bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
return *this;
}
Value value() const noexcept
{
- return static_cast<Value>(bt_field_bool_get_value(this->_libObjPtr()));
+ return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
}
operator Value() const noexcept
ConstBitArrayFieldClass cls() const noexcept
{
return ConstBitArrayFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
CommonBitArrayField<LibObjT>& operator=(const std::uint64_t bits) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_bit_array_set_value_as_integer(this->_libObjPtr(), bits);
+ bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
return *this;
}
std::uint64_t valueAsInteger() const noexcept
{
- return bt_field_bit_array_get_value_as_integer(this->_libObjPtr());
+ return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
}
bool bitValue(const std::uint64_t index) const noexcept
ConstIntegerFieldClass cls() const noexcept
{
return ConstIntegerFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
CommonUnsignedIntegerField<LibObjT>& operator=(const Value val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_integer_unsigned_set_value(this->_libObjPtr(), val);
+ bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
return *this;
}
Value value() const noexcept
{
- return bt_field_integer_unsigned_get_value(this->_libObjPtr());
+ return bt_field_integer_unsigned_get_value(this->libObjPtr());
}
operator Value() const noexcept
ConstIntegerFieldClass cls() const noexcept
{
return ConstIntegerFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
CommonSignedIntegerField<LibObjT>& operator=(const Value val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_integer_signed_set_value(this->_libObjPtr(), val);
+ bt_field_integer_signed_set_value(this->libObjPtr(), val);
return *this;
}
Value value() const noexcept
{
- return bt_field_integer_signed_get_value(this->_libObjPtr());
+ return bt_field_integer_signed_get_value(this->libObjPtr());
}
operator Value() const noexcept
ConstUnsignedEnumerationFieldClass cls() const noexcept
{
return ConstUnsignedEnumerationFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
EnumerationFieldClassMappingLabels labels() const
{
bt_field_class_enumeration_mapping_label_array labelArray;
std::uint64_t count;
- const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->_libObjPtr(),
+ const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
&labelArray, &count);
if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
ConstSignedEnumerationFieldClass cls() const noexcept
{
return ConstSignedEnumerationFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
EnumerationFieldClassMappingLabels labels() const
bt_field_class_enumeration_mapping_label_array labelArray;
std::uint64_t count;
const auto status =
- bt_field_enumeration_signed_get_mapping_labels(this->_libObjPtr(), &labelArray, &count);
+ bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_real_single_precision_set_value(this->_libObjPtr(), val);
+ bt_field_real_single_precision_set_value(this->libObjPtr(), val);
return *this;
}
Value value() const noexcept
{
- return bt_field_real_single_precision_get_value(this->_libObjPtr());
+ return bt_field_real_single_precision_get_value(this->libObjPtr());
}
operator Value() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_real_single_precision_set_value(this->_libObjPtr(), val);
+ bt_field_real_single_precision_set_value(this->libObjPtr(), val);
return *this;
}
Value value() const noexcept
{
- return bt_field_real_single_precision_get_value(this->_libObjPtr());
+ return bt_field_real_single_precision_get_value(this->libObjPtr());
}
operator Value() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_field_string_set_value(this->_libObjPtr(), val);
+ const auto status = bt_field_string_set_value(this->libObjPtr(), val);
if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_string_clear(this->_libObjPtr());
+ bt_field_string_clear(this->libObjPtr());
}
bpstd::string_view value() const noexcept
{
- return bt_field_string_get_value(this->_libObjPtr());
+ return bt_field_string_get_value(this->libObjPtr());
}
};
ConstStructureFieldClass cls() const noexcept
{
return ConstStructureFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
std::uint64_t size() const noexcept
ConstField operator[](const std::uint64_t index) const noexcept
{
return ConstField {internal::CommonStructureFieldSpec<const bt_field>::memberFieldByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
{
- return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->_libObjPtr(), index)};
+ return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
}
nonstd::optional<ConstField> operator[](const char * const name) const noexcept
{
const auto libObjPtr =
- internal::CommonStructureFieldSpec<const bt_field>::memberFieldByName(
- this->_libObjPtr(), name);
+ internal::CommonStructureFieldSpec<const bt_field>::memberFieldByName(this->libObjPtr(),
+ name);
if (libObjPtr) {
return ConstField {libObjPtr};
nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) noexcept
{
- const auto libObjPtr = _Spec::memberFieldByName(this->_libObjPtr(), name);
+ const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
if (libObjPtr) {
return CommonField<LibObjT> {libObjPtr};
ConstArrayFieldClass cls() const noexcept
{
return ConstArrayFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
std::uint64_t length() const noexcept
{
- return bt_field_array_get_length(this->_libObjPtr());
+ return bt_field_array_get_length(this->libObjPtr());
}
ConstField operator[](const std::uint64_t index) const noexcept
{
return ConstField {internal::CommonArrayFieldSpec<const bt_field>::elementFieldByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
{
- return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->_libObjPtr(), index)};
+ return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
}
};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_field_array_dynamic_set_length(this->_libObjPtr(), length);
+ const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
ConstOptionFieldClass cls() const noexcept
{
return ConstOptionFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
void hasField(const bool hasField) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_field_option_set_has_field(this->_libObjPtr(), static_cast<bt_bool>(hasField));
+ bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
}
bool hasField() const noexcept
nonstd::optional<ConstField> field() const noexcept
{
const auto libObjPtr =
- internal::CommonOptionFieldSpec<const bt_field>::field(this->_libObjPtr());
+ internal::CommonOptionFieldSpec<const bt_field>::field(this->libObjPtr());
if (libObjPtr) {
return ConstField {libObjPtr};
nonstd::optional<CommonField<LibObjT>> field() noexcept
{
- const auto libObjPtr = _Spec::field(this->_libObjPtr());
+ const auto libObjPtr = _Spec::field(this->libObjPtr());
if (libObjPtr) {
return CommonField<LibObjT> {libObjPtr};
ConstVariantFieldClass cls() const noexcept
{
return ConstVariantFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+ internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
}
Class cls() noexcept
{
- return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+ return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
void selectOption(const std::uint64_t index) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- static_cast<void>(bt_field_variant_select_option_by_index(this->_libObjPtr(), index));
+ static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
}
ConstField selectedOptionField() const noexcept
{
return ConstField {internal::CommonVariantFieldSpec<const bt_field>::selectedOptionField(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
CommonField<LibObjT> selectedOptionField() noexcept
{
- return CommonField<LibObjT> {_Spec::selectedOptionField(this->_libObjPtr())};
+ return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
}
std::uint64_t selectedOptionIndex() const noexcept
{
- return bt_field_variant_get_selected_option_index(this->_libObjPtr());
+ return bt_field_variant_get_selected_option_index(this->libObjPtr());
}
};
CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
{
BT_ASSERT_DBG(this->isBool());
- return CommonBoolField<LibObjT> {this->_libObjPtr()};
+ return CommonBoolField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
{
BT_ASSERT_DBG(this->isBitArray());
- return CommonBitArrayField<LibObjT> {this->_libObjPtr()};
+ return CommonBitArrayField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
{
BT_ASSERT_DBG(this->isUnsignedInteger());
- return CommonUnsignedIntegerField<LibObjT> {this->_libObjPtr()};
+ return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
{
BT_ASSERT_DBG(this->isSignedInteger());
- return CommonSignedIntegerField<LibObjT> {this->_libObjPtr()};
+ return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
{
BT_ASSERT_DBG(this->isUnsignedEnumeration());
- return CommonUnsignedEnumerationField<LibObjT> {this->_libObjPtr()};
+ return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
{
BT_ASSERT_DBG(this->isSignedEnumeration());
- return CommonSignedEnumerationField<LibObjT> {this->_libObjPtr()};
+ return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
{
BT_ASSERT_DBG(this->isSinglePrecisionReal());
- return CommonSinglePrecisionRealField<LibObjT> {this->_libObjPtr()};
+ return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
{
BT_ASSERT_DBG(this->isDoublePrecisionReal());
- return CommonDoublePrecisionRealField<LibObjT> {this->_libObjPtr()};
+ return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
{
BT_ASSERT_DBG(this->isString());
- return CommonStringField<LibObjT> {this->_libObjPtr()};
+ return CommonStringField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
{
BT_ASSERT_DBG(this->isStructure());
- return CommonStructureField<LibObjT> {this->_libObjPtr()};
+ return CommonStructureField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
{
BT_ASSERT_DBG(this->isArray());
- return CommonArrayField<LibObjT> {this->_libObjPtr()};
+ return CommonArrayField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
{
BT_ASSERT_DBG(this->isDynamicArray());
- return CommonDynamicArrayField<LibObjT> {this->_libObjPtr()};
+ return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
{
BT_ASSERT_DBG(this->isOption());
- return CommonOptionField<LibObjT> {this->_libObjPtr()};
+ return CommonOptionField<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
{
BT_ASSERT_DBG(this->isVariant());
- return CommonVariantField<LibObjT> {this->_libObjPtr()};
+ return CommonVariantField<LibObjT> {this->libObjPtr()};
}
} /* namespace bt2 */
template <typename LibObjT>
class CommonIntegerRangeSet final : public internal::BorrowedObj<LibObjT>
{
- /* Allow operator==() to call `other._libObjPtr()` */
+ /* Allow operator==() to call `other.libObjPtr()` */
friend class CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
friend class CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
friend class CommonIntegerRangeSet<bt_integer_range_set_signed>;
friend class CommonIntegerRangeSet<const bt_integer_range_set_signed>;
- /* Allow appendOption() to call `ranges._libObjPtr()` */
+ /* Allow appendOption() to call `ranges.libObjPtr()` */
friend class CommonVariantWithIntegerSelectorFieldClass<
bt_field_class,
ConstVariantWithIntegerSelectorFieldClassOption<
ConstVariantWithIntegerSelectorFieldClassOption<
const bt_field_class_variant_with_selector_field_integer_signed_option>>;
- /* Allow create*FieldClass() to call `ranges._libObjPtr()` */
+ /* Allow create*FieldClass() to call `ranges.libObjPtr()` */
friend class CommonTraceClass<bt_trace_class>;
private:
template <typename OtherLibObjT>
bool operator==(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
{
- return _Spec::isEqual(this->_libObjPtr(), other._libObjPtr());
+ return _Spec::isEqual(this->libObjPtr(), other.libObjPtr());
}
template <typename OtherLibObjT>
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = _Spec::addRange(this->_libObjPtr(), lower, upper);
+ const auto status = _Spec::addRange(this->libObjPtr(), lower, upper);
if (status == BT_INTEGER_RANGE_SET_ADD_RANGE_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
std::uint64_t size() const noexcept
{
- return _Spec::size(this->_libObjPtr());
+ return _Spec::size(this->libObjPtr());
}
Range operator[](const std::uint64_t index) const noexcept
{
- return Range {_Spec::rangeByIndex(this->_libObjPtr(), index)};
+ return Range {_Spec::rangeByIndex(this->libObjPtr(), index)};
}
Shared shared() const noexcept
bool operator==(const _ThisConstIntegerRange& other) const noexcept
{
- return internal::ConstIntegerRangeSpec<LibObjT>::isEqual(this->_libObjPtr(),
- other._libObjPtr());
+ return internal::ConstIntegerRangeSpec<LibObjT>::isEqual(this->libObjPtr(),
+ other.libObjPtr());
}
bool operator!=(const _ThisConstIntegerRange& other) const noexcept
Value lower() const noexcept
{
- return internal::ConstIntegerRangeSpec<LibObjT>::lower(this->_libObjPtr());
+ return internal::ConstIntegerRangeSpec<LibObjT>::lower(this->libObjPtr());
}
Value upper() const noexcept
{
- return internal::ConstIntegerRangeSpec<LibObjT>::upper(this->_libObjPtr());
+ return internal::ConstIntegerRangeSpec<LibObjT>::upper(this->libObjPtr());
}
};
* `LibObjT` is the direct libbabeltrace2 object type, for example
* `bt_stream_class` or `const bt_value`.
*
- * Methods of a derived class can call _libObjPtr() to access the
+ * Methods of a derived class can call libObjPtr() to access the
* libbabeltrace2 object pointer.
*/
template <typename LibObjT>
template <typename AnyLibObjT>
friend class BorrowedObj;
- /*
- * This is to allow a `SharedObj<_ThisBorrowedObj, LibObjT, ...>`
- * instance containing a `BorrowedObj<LibObjT>` instance to access
- * _libObjPtr() in order to increment/decrement its libbabeltrace2
- * reference count.
- */
- template <typename ObjT, typename AnyLibObjT, typename RefFuncsT>
- friend class SharedObj;
-
protected:
/* libbabeltrace2 object pointer */
using _LibObjPtr = LibObjT *;
return _mLibObjPtr == other._mLibObjPtr;
}
-protected:
/* Wrapped libbabeltrace2 object pointer */
- _LibObjPtr _libObjPtr() const noexcept
+ _LibObjPtr libObjPtr() const noexcept
{
return _mLibObjPtr;
}
void _getRef() const noexcept
{
if (_mObj) {
- RefFuncsT::get(_mObj->_libObjPtr());
+ RefFuncsT::get(_mObj->libObjPtr());
}
}
void _putRef() const noexcept
{
if (_mObj) {
- RefFuncsT::put(_mObj->_libObjPtr());
+ RefFuncsT::put(_mObj->libObjPtr());
}
}
MessageType type() const noexcept
{
- return static_cast<MessageType>(bt_message_get_type(this->_libObjPtr()));
+ return static_cast<MessageType>(bt_message_get_type(this->libObjPtr()));
}
bool isStreamBeginning() const noexcept
ConstStream stream() const noexcept
{
return ConstStream {internal::CommonStreamBeginningMessageSpec<const bt_message>::stream(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
_Stream stream() noexcept
{
return _Stream {
- internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+ internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->libObjPtr())};
}
void defaultClockSnapshot(const std::uint64_t val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_message_stream_beginning_set_default_clock_snapshot(this->_libObjPtr(), val);
+ bt_message_stream_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
}
nonstd::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
{
const bt_clock_snapshot *libObjPtr;
const auto state = bt_message_stream_beginning_borrow_default_clock_snapshot_const(
- this->_libObjPtr(), &libObjPtr);
+ this->libObjPtr(), &libObjPtr);
if (state == BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN) {
return ConstClockSnapshot {libObjPtr};
ConstStream stream() const noexcept
{
return ConstStream {
- internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->_libObjPtr())};
+ internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->libObjPtr())};
}
_Stream stream() noexcept
{
- return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+ return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->libObjPtr())};
}
void defaultClockSnapshot(const std::uint64_t val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_message_stream_end_set_default_clock_snapshot(this->_libObjPtr(), val);
+ bt_message_stream_end_set_default_clock_snapshot(this->libObjPtr(), val);
}
nonstd::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
{
const bt_clock_snapshot *libObjPtr;
const auto state = bt_message_stream_end_borrow_default_clock_snapshot_const(
- this->_libObjPtr(), &libObjPtr);
+ this->libObjPtr(), &libObjPtr);
if (state == BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN) {
return ConstClockSnapshot {libObjPtr};
ConstPacket packet() const noexcept
{
return ConstPacket {internal::CommonPacketBeginningMessageSpec<const bt_message>::packet(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
_Packet packet() noexcept
{
return _Packet {
- internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->_libObjPtr())};
+ internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->libObjPtr())};
}
void defaultClockSnapshot(const std::uint64_t val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_message_packet_beginning_set_default_clock_snapshot(this->_libObjPtr(), val);
+ bt_message_packet_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
}
ConstClockSnapshot defaultClockSnapshot() const noexcept
{
const auto libObjPtr =
- bt_message_packet_beginning_borrow_default_clock_snapshot_const(this->_libObjPtr());
+ bt_message_packet_beginning_borrow_default_clock_snapshot_const(this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
ConstPacket packet() const noexcept
{
return ConstPacket {
- internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->_libObjPtr())};
+ internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->libObjPtr())};
}
_Packet packet() noexcept
{
- return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->_libObjPtr())};
+ return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->libObjPtr())};
}
void defaultClockSnapshot(const std::uint64_t val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_message_packet_end_set_default_clock_snapshot(this->_libObjPtr(), val);
+ bt_message_packet_end_set_default_clock_snapshot(this->libObjPtr(), val);
}
ConstClockSnapshot defaultClockSnapshot() const noexcept
{
const auto libObjPtr =
- bt_message_packet_end_borrow_default_clock_snapshot_const(this->_libObjPtr());
+ bt_message_packet_end_borrow_default_clock_snapshot_const(this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
ConstEvent event() const noexcept
{
return ConstEvent {
- internal::CommonEventMessageSpec<const bt_message>::event(this->_libObjPtr())};
+ internal::CommonEventMessageSpec<const bt_message>::event(this->libObjPtr())};
}
_Event event() noexcept
{
- return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->_libObjPtr())};
+ return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
}
ConstClockSnapshot defaultClockSnapshot() const noexcept
{
const auto libObjPtr =
- bt_message_event_borrow_default_clock_snapshot_const(this->_libObjPtr());
+ bt_message_event_borrow_default_clock_snapshot_const(this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
ConstStream stream() const noexcept
{
return ConstStream {internal::CommonDiscardedEventsMessageSpec<const bt_message>::stream(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
_Stream stream() noexcept
{
return _Stream {
- internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+ internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
}
ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
{
const auto libObjPtr =
bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
- this->_libObjPtr());
+ this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
ConstClockSnapshot endDefaultClockSnapshot() const noexcept
{
const auto libObjPtr =
- bt_message_discarded_events_borrow_end_default_clock_snapshot_const(this->_libObjPtr());
+ bt_message_discarded_events_borrow_end_default_clock_snapshot_const(this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_message_discarded_events_set_count(this->_libObjPtr(), count);
+ bt_message_discarded_events_set_count(this->libObjPtr(), count);
}
nonstd::optional<std::uint64_t> count() const noexcept
{
std::uint64_t count;
- const auto avail = bt_message_discarded_events_get_count(this->_libObjPtr(), &count);
+ const auto avail = bt_message_discarded_events_get_count(this->libObjPtr(), &count);
if (avail) {
return count;
ConstStream stream() const noexcept
{
return ConstStream {internal::CommonDiscardedPacketsMessageSpec<const bt_message>::stream(
- this->_libObjPtr())};
+ this->libObjPtr())};
}
_Stream stream() noexcept
{
return _Stream {
- internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+ internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
}
ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
{
const auto libObjPtr =
bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
- this->_libObjPtr());
+ this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
ConstClockSnapshot endDefaultClockSnapshot() const noexcept
{
- const auto libObjPtr = bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
- this->_libObjPtr());
+ const auto libObjPtr =
+ bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_message_discarded_packets_set_count(this->_libObjPtr(), count);
+ bt_message_discarded_packets_set_count(this->libObjPtr(), count);
}
nonstd::optional<std::uint64_t> count() const noexcept
{
std::uint64_t count;
- const auto avail = bt_message_discarded_packets_get_count(this->_libObjPtr(), &count);
+ const auto avail = bt_message_discarded_packets_get_count(this->libObjPtr(), &count);
if (avail) {
return count;
ConstClockSnapshot clockSnapshot() const noexcept
{
const auto libObjPtr =
- bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(this->_libObjPtr());
+ bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(this->libObjPtr());
return ConstClockSnapshot {libObjPtr};
}
CommonStreamBeginningMessage<LibObjT> CommonMessage<LibObjT>::asStreamBeginning() const noexcept
{
BT_ASSERT_DBG(this->isStreamBeginning());
- return CommonStreamBeginningMessage<LibObjT> {this->_libObjPtr()};
+ return CommonStreamBeginningMessage<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonStreamEndMessage<LibObjT> CommonMessage<LibObjT>::asStreamEnd() const noexcept
{
BT_ASSERT_DBG(this->isStreamEnd());
- return CommonStreamEndMessage<LibObjT> {this->_libObjPtr()};
+ return CommonStreamEndMessage<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonPacketBeginningMessage<LibObjT> CommonMessage<LibObjT>::asPacketBeginning() const noexcept
{
BT_ASSERT_DBG(this->isPacketBeginning());
- return CommonPacketBeginningMessage<LibObjT> {this->_libObjPtr()};
+ return CommonPacketBeginningMessage<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonPacketEndMessage<LibObjT> CommonMessage<LibObjT>::asPacketEnd() const noexcept
{
BT_ASSERT_DBG(this->isPacketEnd());
- return CommonPacketEndMessage<LibObjT> {this->_libObjPtr()};
+ return CommonPacketEndMessage<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonEventMessage<LibObjT> CommonMessage<LibObjT>::asEvent() const noexcept
{
BT_ASSERT_DBG(this->isEvent());
- return CommonEventMessage<LibObjT> {this->_libObjPtr()};
+ return CommonEventMessage<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonDiscardedEventsMessage<LibObjT> CommonMessage<LibObjT>::asDiscardedEvents() const noexcept
{
BT_ASSERT_DBG(this->isDiscardedEvents());
- return CommonDiscardedEventsMessage<LibObjT> {this->_libObjPtr()};
+ return CommonDiscardedEventsMessage<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonMessage<LibObjT>::asMessageIteratorInactivity() const noexcept
{
BT_ASSERT_DBG(this->isMessageIteratorInactivity());
- return CommonMessageIteratorInactivityMessage<LibObjT> {this->_libObjPtr()};
+ return CommonMessageIteratorInactivityMessage<LibObjT> {this->libObjPtr()};
}
} /* namespace bt2 */
nonstd::optional<ConstStructureField> payloadField() const noexcept
{
- const auto libObjPtr = _ConstSpec::payloadField(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::payloadField(this->libObjPtr());
if (libObjPtr) {
return ConstStructureField {libObjPtr};
nonstd::optional<_StructureField> payloadField() noexcept
{
- const auto libObjPtr = _Spec::payloadField(this->_libObjPtr());
+ const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
if (libObjPtr) {
return _StructureField {libObjPtr};
nonstd::optional<ConstStructureField> specificContextField() const noexcept
{
- const auto libObjPtr = _ConstSpec::specificContextField(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::specificContextField(this->libObjPtr());
if (libObjPtr) {
return ConstStructureField {libObjPtr};
nonstd::optional<_StructureField> specificContextField() noexcept
{
- const auto libObjPtr = _Spec::specificContextField(this->_libObjPtr());
+ const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
if (libObjPtr) {
return _StructureField {libObjPtr};
nonstd::optional<ConstStructureField> commonContextField() const noexcept
{
- const auto libObjPtr = _ConstSpec::commonContextField(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::commonContextField(this->libObjPtr());
if (libObjPtr) {
return ConstStructureField {libObjPtr};
nonstd::optional<_StructureField> commonContextField() noexcept
{
- const auto libObjPtr = _Spec::commonContextField(this->_libObjPtr());
+ const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
if (libObjPtr) {
return _StructureField {libObjPtr};
nonstd::optional<ConstStructureField> contextField() const noexcept
{
- const auto libObjPtr = _ConstSpec::contextField(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::contextField(this->libObjPtr());
if (libObjPtr) {
return ConstStructureField {libObjPtr};
nonstd::optional<_StructureField> contextField() noexcept
{
- const auto libObjPtr = _Spec::contextField(this->_libObjPtr());
+ const auto libObjPtr = _Spec::contextField(this->libObjPtr());
if (libObjPtr) {
return _StructureField {libObjPtr};
template <typename LibObjT>
nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
{
- const auto libObjPtr = _ConstSpec::packet(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::packet(this->libObjPtr());
if (libObjPtr) {
return ConstPacket {libObjPtr};
template <typename LibObjT>
nonstd::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() noexcept
{
- const auto libObjPtr = _Spec::packet(this->_libObjPtr());
+ const auto libObjPtr = _Spec::packet(this->libObjPtr());
if (libObjPtr) {
return _Packet {libObjPtr};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto libObjPtr = bt_packet_create(this->_libObjPtr());
+ const auto libObjPtr = bt_packet_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
return Packet::Shared {Packet {libObjPtr}};
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)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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 {};
nonstd::optional<bpstd::string_view> name() const noexcept
{
- const auto name = bt_stream_get_name(this->_libObjPtr());
+ const auto name = bt_stream_get_name(this->libObjPtr());
if (name) {
return name;
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_stream_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
template <typename LibObjT>
ConstStream CommonEvent<LibObjT>::stream() const noexcept
{
- return ConstStream {_ConstSpec::stream(this->_libObjPtr())};
+ return ConstStream {_ConstSpec::stream(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() noexcept
{
- return _Stream {_Spec::stream(this->_libObjPtr())};
+ return _Stream {_Spec::stream(this->libObjPtr())};
}
template <typename LibObjT>
ConstStream CommonPacket<LibObjT>::stream() const noexcept
{
- return ConstStream {_ConstSpec::stream(this->_libObjPtr())};
+ return ConstStream {_ConstSpec::stream(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() noexcept
{
- return _Stream {_Spec::stream(this->_libObjPtr())};
+ return _Stream {_Spec::stream(this->libObjPtr())};
}
namespace internal {
template <typename LibObjT>
class CommonTrace final : public internal::BorrowedObj<LibObjT>
{
- /* Allow instantiate() to call `trace._libObjPtr()` */
+ /* Allow instantiate() to call `trace.libObjPtr()` */
friend class CommonStreamClass<bt_stream_class>;
private:
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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 {};
nonstd::optional<bpstd::string_view> name() const noexcept
{
- const auto name = bt_trace_get_name(this->_libObjPtr());
+ const auto name = bt_trace_get_name(this->libObjPtr());
if (name) {
return name;
void uuid(const std::uint8_t * const uuid) noexcept
{
- bt_trace_set_uuid(this->_libObjPtr(), uuid);
+ bt_trace_set_uuid(this->libObjPtr(), uuid);
}
nonstd::optional<bt2_common::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};
std::uint64_t size() 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
{
- return ConstStream {_ConstSpec::streamByIndex(this->_libObjPtr(), index)};
+ return ConstStream {_ConstSpec::streamByIndex(this->libObjPtr(), index)};
}
_Stream operator[](const std::uint64_t index) noexcept
{
- return _Stream {_Spec::streamByIndex(this->_libObjPtr(), index)};
+ return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
}
nonstd::optional<ConstStream> streamById(const std::uint64_t id) const noexcept
{
- const auto libObjPtr = _ConstSpec::streamById(this->_libObjPtr(), id);
+ const auto libObjPtr = _ConstSpec::streamById(this->libObjPtr(), id);
if (libObjPtr) {
return ConstStream {libObjPtr};
nonstd::optional<_Stream> streamById(const std::uint64_t id) noexcept
{
- const auto libObjPtr = _Spec::streamById(this->_libObjPtr(), id);
+ const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
if (libObjPtr) {
return _Stream {libObjPtr};
{
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 {};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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 {};
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);
+ bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
if (libObjPtr) {
return ConstValue {libObjPtr};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_trace_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
template <typename LibObjT>
ConstTrace CommonStream<LibObjT>::trace() const noexcept
{
- return ConstTrace {_ConstSpec::trace(this->_libObjPtr())};
+ return ConstTrace {_ConstSpec::trace(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() noexcept
{
- return _Trace {_Spec::trace(this->_libObjPtr())};
+ return _Trace {_Spec::trace(this->libObjPtr())};
}
namespace internal {
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)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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 {};
nonstd::optional<bpstd::string_view> name() const noexcept
{
- const auto name = bt_event_class_get_name(this->_libObjPtr());
+ const auto name = bt_event_class_get_name(this->libObjPtr());
if (name) {
return name;
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_event_class_set_log_level(this->_libObjPtr(),
+ bt_event_class_set_log_level(this->libObjPtr(),
static_cast<bt_event_class_log_level>(logLevel));
}
nonstd::optional<LogLevel> logLevel() const noexcept
{
bt_event_class_log_level libLogLevel;
- const auto avail = bt_event_class_get_log_level(this->_libObjPtr(), &libLogLevel);
+ const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
return static_cast<LogLevel>(libLogLevel);
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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 {};
nonstd::optional<bpstd::string_view> emfUri() const noexcept
{
- const auto emfUri = bt_event_class_get_emf_uri(this->_libObjPtr());
+ const auto emfUri = bt_event_class_get_emf_uri(this->libObjPtr());
if (emfUri) {
return emfUri;
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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());
+ const auto libObjPtr = _ConstSpec::payloadFieldClass(this->libObjPtr());
if (libObjPtr) {
return ConstStructureFieldClass {libObjPtr};
nonstd::optional<_StructureFieldClass> payloadFieldClass() noexcept
{
- const auto libObjPtr = _Spec::payloadFieldClass(this->_libObjPtr());
+ const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
if (libObjPtr) {
return _StructureFieldClass {libObjPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_event_class_set_specific_context_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());
+ const auto libObjPtr = _ConstSpec::specificContextFieldClass(this->libObjPtr());
if (libObjPtr) {
return ConstStructureFieldClass {libObjPtr};
nonstd::optional<_StructureFieldClass> specificContextFieldClass() noexcept
{
- const auto libObjPtr = _Spec::specificContextFieldClass(this->_libObjPtr());
+ const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
if (libObjPtr) {
return _StructureFieldClass {libObjPtr};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_event_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
template <typename LibObjT>
ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
{
- return ConstEventClass {_ConstSpec::cls(this->_libObjPtr())};
+ return ConstEventClass {_ConstSpec::cls(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() noexcept
{
- return Class {_Spec::cls(this->_libObjPtr())};
+ return Class {_Spec::cls(this->libObjPtr())};
}
namespace internal {
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
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)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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 {};
nonstd::optional<bpstd::string_view> name() const noexcept
{
- const auto name = bt_stream_class_get_name(this->_libObjPtr());
+ const auto name = bt_stream_class_get_name(this->libObjPtr());
if (name) {
return name;
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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));
}
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
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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));
}
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,
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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));
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,
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_class_set_supports_discarded_events(
- this->_libObjPtr(), static_cast<bt_bool>(supportsPackets),
+ this->libObjPtr(), static_cast<bt_bool>(supportsPackets),
static_cast<bt_bool>(withDefaultClkSnapshots));
}
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,
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_class_set_supports_discarded_packets(
- this->_libObjPtr(), static_cast<bt_bool>(supportsPackets),
+ this->libObjPtr(), static_cast<bt_bool>(supportsPackets),
static_cast<bt_bool>(withDefaultClkSnapshots));
}
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)
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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);
}
nonstd::optional<ConstClockClass> defaultClockClass() const noexcept
{
- const auto libObjPtr = _ConstSpec::defaultClockClass(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::defaultClockClass(this->libObjPtr());
if (libObjPtr) {
return ConstClockClass {libObjPtr};
nonstd::optional<_ClockClass> defaultClockClass() noexcept
{
- const auto libObjPtr = _Spec::defaultClockClass(this->_libObjPtr());
+ const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
if (libObjPtr) {
return _ClockClass {libObjPtr};
std::uint64_t size() const noexcept
{
- return bt_stream_class_get_event_class_count(this->_libObjPtr());
+ return bt_stream_class_get_event_class_count(this->libObjPtr());
}
ConstEventClass operator[](const std::uint64_t index) const noexcept
{
- return ConstEventClass {_ConstSpec::eventClassByIndex(this->_libObjPtr(), index)};
+ return ConstEventClass {_ConstSpec::eventClassByIndex(this->libObjPtr(), index)};
}
_EventClass operator[](const std::uint64_t index) noexcept
{
- return _EventClass {_Spec::eventClassByIndex(this->_libObjPtr(), index)};
+ return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
}
nonstd::optional<ConstEventClass> eventClassById(const std::uint64_t id) const noexcept
{
- const auto libObjPtr = _ConstSpec::eventClassById(this->_libObjPtr(), id);
+ const auto libObjPtr = _ConstSpec::eventClassById(this->libObjPtr(), id);
if (libObjPtr) {
return ConstEventClass {libObjPtr};
nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) noexcept
{
- const auto libObjPtr = _Spec::eventClassById(this->_libObjPtr(), id);
+ const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
if (libObjPtr) {
return _EventClass {libObjPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_stream_class_set_packet_context_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 {};
nonstd::optional<ConstStructureFieldClass> packetContextFieldClass() const noexcept
{
- const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->_libObjPtr());
+ const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->libObjPtr());
if (libObjPtr) {
return ConstStructureFieldClass {libObjPtr};
nonstd::optional<_StructureFieldClass> packetContextFieldClass() noexcept
{
- const auto libObjPtr = _Spec::packetContextFieldClass(this->_libObjPtr());
+ const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
if (libObjPtr) {
return _StructureFieldClass {libObjPtr};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_stream_class_set_event_common_context_field_class(this->_libObjPtr(),
- fc._libObjPtr());
+ const auto status =
+ bt_stream_class_set_event_common_context_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());
+ const auto libObjPtr = _ConstSpec::eventCommonContextFieldClass(this->libObjPtr());
if (libObjPtr) {
return ConstStructureFieldClass {libObjPtr};
nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() noexcept
{
- const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->_libObjPtr());
+ const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
if (libObjPtr) {
return _StructureFieldClass {libObjPtr};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_stream_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
template <typename LibObjT>
ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
{
- return ConstStreamClass {_ConstSpec::streamClass(this->_libObjPtr())};
+ return ConstStreamClass {_ConstSpec::streamClass(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonEventClass<LibObjT>::_StreamClass CommonEventClass<LibObjT>::streamClass() noexcept
{
- return _StreamClass {_Spec::streamClass(this->_libObjPtr())};
+ return _StreamClass {_Spec::streamClass(this->libObjPtr())};
}
template <typename LibObjT>
ConstStreamClass CommonStream<LibObjT>::cls() const noexcept
{
- return ConstStreamClass {_ConstSpec::cls(this->_libObjPtr())};
+ return ConstStreamClass {_ConstSpec::cls(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() noexcept
{
- return Class {_Spec::cls(this->_libObjPtr())};
+ return Class {_Spec::cls(this->libObjPtr())};
}
namespace internal {
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto libObjPtr = bt_trace_create(this->_libObjPtr());
+ const auto libObjPtr = bt_trace_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
return Trace::Shared {Trace {libObjPtr}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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}};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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}};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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}};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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 {
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto libObjPtr = bt_field_class_structure_create(this->_libObjPtr());
+ const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
internal::validateCreatedObjPtr(libObjPtr);
return StructureFieldClass::Shared {StructureFieldClass {libObjPtr}};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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}};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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 {
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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 {
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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 {
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto libObjPtr = bt_field_class_variant_create(this->_libObjPtr(), nullptr);
+ const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
internal::validateCreatedObjPtr(libObjPtr);
return VariantWithoutSelectorFieldClass::Shared {
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- 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));
}
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
{
- 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
{
- return ConstStreamClass {_ConstSpec::streamClassByIndex(this->_libObjPtr(), index)};
+ return ConstStreamClass {_ConstSpec::streamClassByIndex(this->libObjPtr(), index)};
}
_StreamClass operator[](const std::uint64_t index) noexcept
{
- return _StreamClass {_Spec::streamClassByIndex(this->_libObjPtr(), index)};
+ 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);
+ const auto libObjPtr = _ConstSpec::streamClassById(this->libObjPtr(), id);
if (libObjPtr) {
return ConstStreamClass {libObjPtr};
nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) noexcept
{
- const auto libObjPtr = _Spec::streamClassById(this->_libObjPtr(), id);
+ const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
if (libObjPtr) {
return _StreamClass {libObjPtr};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_trace_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+ bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
ConstMapValue userAttributes() const noexcept
{
- return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+ return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
}
UserAttributes userAttributes() noexcept
{
- return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+ return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
Shared shared() const noexcept
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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;
template <typename LibObjT>
ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
{
- return ConstTraceClass {_ConstSpec::traceClass(this->_libObjPtr())};
+ return ConstTraceClass {_ConstSpec::traceClass(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonStreamClass<LibObjT>::_TraceClass CommonStreamClass<LibObjT>::traceClass() noexcept
{
- return _TraceClass {_Spec::traceClass(this->_libObjPtr())};
+ return _TraceClass {_Spec::traceClass(this->libObjPtr())};
}
template <typename LibObjT>
ConstTraceClass CommonTrace<LibObjT>::cls() const noexcept
{
- return ConstTraceClass {_ConstSpec::cls(this->_libObjPtr())};
+ return ConstTraceClass {_ConstSpec::cls(this->libObjPtr())};
}
template <typename LibObjT>
typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() noexcept
{
- return Class {_Spec::cls(this->_libObjPtr())};
+ return Class {_Spec::cls(this->libObjPtr())};
}
} /* namespace bt2 */
template <typename LibObjT>
class CommonValue : public internal::BorrowedObj<LibObjT>
{
- /* Allow append() to call `val._libObjPtr()` */
+ /* Allow append() to call `val.libObjPtr()` */
friend class CommonArrayValue<bt_value>;
- /* Allow insert() to call `val._libObjPtr()` */
+ /* Allow insert() to call `val.libObjPtr()` */
friend class CommonMapValue<bt_value>;
- /* Allow userAttributes() to call `val._libObjPtr()` */
+ /* Allow userAttributes() to call `val.libObjPtr()` */
friend class CommonClockClass<bt_clock_class>;
friend class CommonFieldClass<bt_field_class>;
friend class CommonTraceClass<bt_trace_class>;
friend class CommonEventClass<bt_event_class>;
friend class CommonStream<bt_stream>;
- /* Allow operator==() to call `other._libObjPtr()` */
+ /* Allow operator==() to call `other.libObjPtr()` */
friend class CommonValue<bt_value>;
friend class CommonValue<const bt_value>;
ValueType type() const noexcept
{
- return static_cast<ValueType>(bt_value_get_type(this->_libObjPtr()));
+ return static_cast<ValueType>(bt_value_get_type(this->libObjPtr()));
}
bool isNull() const noexcept
template <typename OtherLibObjT>
bool operator==(const CommonValue<OtherLibObjT>& other) const noexcept
{
- return static_cast<bool>(bt_value_is_equal(this->_libObjPtr(), other._libObjPtr()));
+ return static_cast<bool>(bt_value_is_equal(this->libObjPtr(), other.libObjPtr()));
}
template <typename OtherLibObjT>
protected:
bool _libTypeIs(const bt_value_type type) const noexcept
{
- return bt_value_type_is(bt_value_get_type(this->_libObjPtr()), type);
+ return bt_value_type_is(bt_value_get_type(this->libObjPtr()), type);
}
};
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_value_bool_set(this->_libObjPtr(), static_cast<bt_bool>(rawVal));
+ bt_value_bool_set(this->libObjPtr(), static_cast<bt_bool>(rawVal));
return *this;
}
Value value() const noexcept
{
- return static_cast<Value>(bt_value_bool_get(this->_libObjPtr()));
+ return static_cast<Value>(bt_value_bool_get(this->libObjPtr()));
}
operator Value() const noexcept
CommonUnsignedIntegerValue<LibObjT>& operator=(const Value rawVal) noexcept
{
- bt_value_integer_unsigned_set(this->_libObjPtr(), rawVal);
+ bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
return *this;
}
Value value() const noexcept
{
- return bt_value_integer_unsigned_get(this->_libObjPtr());
+ return bt_value_integer_unsigned_get(this->libObjPtr());
}
operator Value() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_value_integer_signed_set(this->_libObjPtr(), rawVal);
+ bt_value_integer_signed_set(this->libObjPtr(), rawVal);
return *this;
}
Value value() const noexcept
{
- return bt_value_integer_signed_get(this->_libObjPtr());
+ return bt_value_integer_signed_get(this->libObjPtr());
}
operator Value() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- bt_value_real_set(this->_libObjPtr(), rawVal);
+ bt_value_real_set(this->libObjPtr(), rawVal);
return *this;
}
Value value() const noexcept
{
- return bt_value_real_get(this->_libObjPtr());
+ return bt_value_real_get(this->libObjPtr());
}
operator Value() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_string_set(this->_libObjPtr(), rawVal);
+ const auto status = bt_value_string_set(this->libObjPtr(), rawVal);
if (status == BT_VALUE_STRING_SET_STATUS_MEMORY_ERROR) {
throw LibMemoryError {};
bpstd::string_view value() const noexcept
{
- return bt_value_string_get(this->_libObjPtr());
+ return bt_value_string_get(this->libObjPtr());
}
Shared shared() const noexcept
std::uint64_t length() const noexcept
{
- return bt_value_array_get_length(this->_libObjPtr());
+ return bt_value_array_get_length(this->libObjPtr());
}
/* Required by the `CommonIterator` template class */
ConstValue operator[](const std::uint64_t index) const noexcept
{
return ConstValue {internal::CommonArrayValueSpec<const bt_value>::elementByIndex(
- this->_libObjPtr(), index)};
+ this->libObjPtr(), index)};
}
CommonValue<LibObjT> operator[](const std::uint64_t index) noexcept
{
return CommonValue<LibObjT> {
- internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->_libObjPtr(), index)};
+ internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
}
void append(const Value& val)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_array_append_element(this->_libObjPtr(), val._libObjPtr());
+ const auto status = bt_value_array_append_element(this->libObjPtr(), val.libObjPtr());
this->_handleAppendLibStatus(status);
}
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_value_array_append_bool_element(this->_libObjPtr(), static_cast<bt_bool>(rawVal));
+ bt_value_array_append_bool_element(this->libObjPtr(), static_cast<bt_bool>(rawVal));
this->_handleAppendLibStatus(status);
}
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_value_array_append_unsigned_integer_element(this->_libObjPtr(), rawVal);
+ bt_value_array_append_unsigned_integer_element(this->libObjPtr(), rawVal);
this->_handleAppendLibStatus(status);
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status =
- bt_value_array_append_signed_integer_element(this->_libObjPtr(), rawVal);
+ const auto status = bt_value_array_append_signed_integer_element(this->libObjPtr(), rawVal);
this->_handleAppendLibStatus(status);
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_array_append_real_element(this->_libObjPtr(), rawVal);
+ const auto status = bt_value_array_append_real_element(this->libObjPtr(), rawVal);
this->_handleAppendLibStatus(status);
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_array_append_string_element(this->_libObjPtr(), rawVal);
+ const auto status = bt_value_array_append_string_element(this->libObjPtr(), rawVal);
this->_handleAppendLibStatus(status);
}
std::uint64_t size() const noexcept
{
- return bt_value_map_get_size(this->_libObjPtr());
+ return bt_value_map_get_size(this->libObjPtr());
}
bool isEmpty() const noexcept
nonstd::optional<ConstValue> operator[](const char * const key) const noexcept
{
const auto libObjPtr =
- internal::CommonMapValueSpec<const bt_value>::entryByKey(this->_libObjPtr(), key);
+ internal::CommonMapValueSpec<const bt_value>::entryByKey(this->libObjPtr(), key);
if (!libObjPtr) {
return nonstd::nullopt;
nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) noexcept
{
const auto libObjPtr =
- internal::CommonMapValueSpec<LibObjT>::entryByKey(this->_libObjPtr(), key);
+ internal::CommonMapValueSpec<LibObjT>::entryByKey(this->libObjPtr(), key);
if (!libObjPtr) {
return nonstd::nullopt;
bool hasEntry(const char * const key) const noexcept
{
- return static_cast<bool>(bt_value_map_has_entry(this->_libObjPtr(), key));
+ return static_cast<bool>(bt_value_map_has_entry(this->libObjPtr(), key));
}
bool hasEntry(const std::string& key) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_map_insert_entry(this->_libObjPtr(), key, val._libObjPtr());
+ const auto status = bt_value_map_insert_entry(this->libObjPtr(), key, val.libObjPtr());
this->_handleInsertLibStatus(status);
}
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_value_map_insert_bool_entry(this->_libObjPtr(), key, static_cast<bt_bool>(rawVal));
+ bt_value_map_insert_bool_entry(this->libObjPtr(), key, static_cast<bt_bool>(rawVal));
this->_handleInsertLibStatus(status);
}
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_value_map_insert_unsigned_integer_entry(this->_libObjPtr(), key, rawVal);
+ bt_value_map_insert_unsigned_integer_entry(this->libObjPtr(), key, rawVal);
this->_handleInsertLibStatus(status);
}
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
const auto status =
- bt_value_map_insert_signed_integer_entry(this->_libObjPtr(), key, rawVal);
+ bt_value_map_insert_signed_integer_entry(this->libObjPtr(), key, rawVal);
this->_handleInsertLibStatus(status);
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_map_insert_real_entry(this->_libObjPtr(), key, rawVal);
+ const auto status = bt_value_map_insert_real_entry(this->libObjPtr(), key, rawVal);
this->_handleInsertLibStatus(status);
}
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
- const auto status = bt_value_map_insert_string_entry(this->_libObjPtr(), key, rawVal);
+ const auto status = bt_value_map_insert_string_entry(this->libObjPtr(), key, rawVal);
this->_handleInsertLibStatus(status);
}
void forEach(const internal::CommonMapValueForEachUserFunc<ConstValue>& func) const
{
- internal::CommonMapValueSpec<const bt_value>::forEach(this->_libObjPtr(), func);
+ internal::CommonMapValueSpec<const bt_value>::forEach(this->libObjPtr(), func);
}
void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func)
{
- internal::CommonMapValueSpec<LibObjT>::forEach(this->_libObjPtr(), func);
+ internal::CommonMapValueSpec<LibObjT>::forEach(this->libObjPtr(), func);
}
Shared shared() const noexcept
CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
{
BT_ASSERT_DBG(this->isNull());
- return CommonNullValue<LibObjT> {this->_libObjPtr()};
+ return CommonNullValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonBoolValue<LibObjT> CommonValue<LibObjT>::asBool() const noexcept
{
BT_ASSERT_DBG(this->isBool());
- return CommonBoolValue<LibObjT> {this->_libObjPtr()};
+ return CommonBoolValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonSignedIntegerValue<LibObjT> CommonValue<LibObjT>::asSignedInteger() const noexcept
{
BT_ASSERT_DBG(this->isSignedInteger());
- return CommonSignedIntegerValue<LibObjT> {this->_libObjPtr()};
+ return CommonSignedIntegerValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonUnsignedIntegerValue<LibObjT> CommonValue<LibObjT>::asUnsignedInteger() const noexcept
{
BT_ASSERT_DBG(this->isUnsignedInteger());
- return CommonUnsignedIntegerValue<LibObjT> {this->_libObjPtr()};
+ return CommonUnsignedIntegerValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonRealValue<LibObjT> CommonValue<LibObjT>::asReal() const noexcept
{
BT_ASSERT_DBG(this->isReal());
- return CommonRealValue<LibObjT> {this->_libObjPtr()};
+ return CommonRealValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonStringValue<LibObjT> CommonValue<LibObjT>::asString() const noexcept
{
BT_ASSERT_DBG(this->isString());
- return CommonStringValue<LibObjT> {this->_libObjPtr()};
+ return CommonStringValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonArrayValue<LibObjT> CommonValue<LibObjT>::asArray() const noexcept
{
BT_ASSERT_DBG(this->isArray());
- return CommonArrayValue<LibObjT> {this->_libObjPtr()};
+ return CommonArrayValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonMapValue<LibObjT> CommonValue<LibObjT>::asMap() const noexcept
{
BT_ASSERT_DBG(this->isMap());
- return CommonMapValue<LibObjT> {this->_libObjPtr()};
+ return CommonMapValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_value *libElemPtr;
- const auto status = bt_value_array_append_empty_array_element(this->_libObjPtr(), &libElemPtr);
+ const auto status = bt_value_array_append_empty_array_element(this->libObjPtr(), &libElemPtr);
this->_handleAppendLibStatus(status);
return ArrayValue {libElemPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_value *libElemPtr;
- const auto status = bt_value_array_append_empty_map_element(this->_libObjPtr(), &libElemPtr);
+ const auto status = bt_value_array_append_empty_map_element(this->libObjPtr(), &libElemPtr);
this->_handleAppendLibStatus(status);
return MapValue {libElemPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_value *libEntryPtr;
- const auto status =
- bt_value_map_insert_empty_array_entry(this->_libObjPtr(), key, &libEntryPtr);
+ const auto status = bt_value_map_insert_empty_array_entry(this->libObjPtr(), key, &libEntryPtr);
this->_handleInsertLibStatus(status);
return ArrayValue {libEntryPtr};
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_value *libEntryPtr;
- const auto status = bt_value_map_insert_empty_map_entry(this->_libObjPtr(), key, &libEntryPtr);
+ const auto status = bt_value_map_insert_empty_map_entry(this->libObjPtr(), key, &libEntryPtr);
this->_handleInsertLibStatus(status);
return MapValue {libEntryPtr};
projects / babeltrace.git / commitdiff
