return *this;
}
- void frequency(const std::uint64_t frequency) noexcept
+ void frequency(const std::uint64_t frequency) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return bt_clock_class_get_frequency(this->libObjPtr());
}
- void offset(const ClockClassOffset& offset) noexcept
+ void offset(const ClockClassOffset& offset) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return ClockClassOffset {seconds, cycles};
}
- void precision(const std::uint64_t precision) noexcept
+ void precision(const std::uint64_t precision) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return bt_clock_class_get_precision(this->libObjPtr());
}
- void originIsUnixEpoch(const bool originIsUnixEpoch) noexcept
+ void originIsUnixEpoch(const bool originIsUnixEpoch) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->libObjPtr()));
}
- void name(const char * const name)
+ void name(const char * const name) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void name(const std::string& name)
+ void name(const std::string& name) const
{
this->name(name.data());
}
return nonstd::nullopt;
}
- void description(const char * const description)
+ void description(const char * const description) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void description(const std::string& description)
+ void description(const std::string& description) const
{
this->description(description.data());
}
return nonstd::nullopt;
}
- void uuid(const std::uint8_t * const uuid) noexcept
+ void uuid(const std::uint8_t * const uuid) const noexcept
{
bt_clock_class_set_uuid(this->libObjPtr(), uuid);
}
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {
internal::CommonClockClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
return !(*this == other);
}
- reference operator*() noexcept
+ reference operator*() const noexcept
{
return *_mCurrVal;
}
- pointer operator->() noexcept
+ pointer operator->() const noexcept
{
return &(*_mCurrVal);
}
asVariantWithSignedIntegerSelector() const noexcept;
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {
internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
return *this;
}
- void fieldValueRange(const std::uint64_t n) noexcept
+ void fieldValueRange(const std::uint64_t n) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return bt_field_class_integer_get_field_value_range(this->libObjPtr());
}
- void preferredDisplayBase(const DisplayBase base) noexcept
+ void preferredDisplayBase(const DisplayBase base) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return (*this)[label.data()];
}
- void addMapping(const char * const label, const typename Mapping::RangeSet ranges)
+ void addMapping(const char * const label, const typename Mapping::RangeSet ranges) const
{
const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
this->libObjPtr(), label, ranges.libObjPtr());
}
}
- void addMapping(const std::string& label, const typename Mapping::RangeSet ranges)
+ void addMapping(const std::string& label, const typename Mapping::RangeSet ranges) const
{
this->addMapping(label.data(), ranges);
}
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())};
- }
-
- _FieldClass fieldClass() noexcept
+ _FieldClass fieldClass() const noexcept
{
return _FieldClass {
internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {internal::CommonStructureFieldClassMemberSpec<
- const bt_field_class_structure_member>::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {
internal::CommonStructureFieldClassMemberSpec<LibObjT>::userAttributes(
return *this;
}
- void appendMember(const char * const name, const FieldClass fc)
+ void appendMember(const char * const name, const FieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void appendMember(const std::string& name, const FieldClass fc)
+ void appendMember(const std::string& name, const FieldClass fc) const
{
this->appendMember(name.data(), fc);
}
return Iterator {*this, this->size()};
}
- ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
- {
- return ConstStructureFieldClassMember {
- internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
- this->libObjPtr(), index)};
- }
-
- Member operator[](const std::uint64_t index) noexcept
+ Member operator[](const std::uint64_t index) const noexcept
{
return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
this->libObjPtr(), index)};
}
- nonstd::optional<ConstStructureFieldClassMember>
- operator[](const char * const name) const noexcept
- {
- const auto libObjPtr =
- internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
- this->libObjPtr(), name);
-
- if (libObjPtr) {
- return ConstStructureFieldClassMember {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<ConstStructureFieldClassMember>
- operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
- }
-
- nonstd::optional<Member> operator[](const char * const name) noexcept
+ nonstd::optional<Member> operator[](const char * const name) const noexcept
{
const auto libObjPtr =
internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
return nonstd::nullopt;
}
- nonstd::optional<Member> operator[](const std::string& name) noexcept
+ nonstd::optional<Member> operator[](const std::string& name) const noexcept
{
return (*this)[name.data()];
}
return *this;
}
- ConstFieldClass elementFieldClass() const noexcept
- {
- return ConstFieldClass {
- internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
- this->libObjPtr())};
- }
-
- _FieldClass elementFieldClass() noexcept
+ _FieldClass elementFieldClass() const noexcept
{
return _FieldClass {
internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
return *this;
}
- ConstFieldClass fieldClass() const noexcept
- {
- return ConstFieldClass {
- internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
- this->libObjPtr())};
- }
-
- _FieldClass fieldClass() noexcept
+ _FieldClass fieldClass() const noexcept
{
return _FieldClass {
internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
return nonstd::nullopt;
}
- ConstFieldClass fieldClass() const noexcept
- {
- return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
- const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
- }
-
- _FieldClass fieldClass() noexcept
+ _FieldClass fieldClass() const noexcept
{
return _FieldClass {
internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {internal::CommonVariantFieldClassOptionSpec<
- const bt_field_class_variant_option>::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {internal::CommonVariantFieldClassOptionSpec<LibObjT>::userAttributes(
this->libObjPtr())};
return Iterator {*this, this->size()};
}
- ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
- {
- return ConstVariantFieldClassOption {
- internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
- this->libObjPtr(), index)};
- }
-
- Option operator[](const std::uint64_t index) noexcept
+ Option operator[](const std::uint64_t index) const noexcept
{
return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
this->libObjPtr(), index)};
}
- nonstd::optional<ConstVariantFieldClassOption>
- operator[](const char * const name) const noexcept
- {
- const auto libObjPtr =
- internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
- this->libObjPtr(), name);
-
- if (libObjPtr) {
- return ConstVariantFieldClassOption {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<ConstVariantFieldClassOption>
- operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
- }
-
- nonstd::optional<Option> operator[](const char * const name) noexcept
+ nonstd::optional<Option> operator[](const char * const name) const noexcept
{
const auto libObjPtr =
internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
return nonstd::nullopt;
}
- nonstd::optional<Option> operator[](const std::string& name) noexcept
+ nonstd::optional<Option> operator[](const std::string& name) const noexcept
{
return (*this)[name.data()];
}
return *this;
}
- void appendOption(const char * const name, const FieldClass fc)
+ void appendOption(const char * const name, const FieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc)
+ void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc) const
{
this->appendOption(name ? name->data() : nullptr, fc);
}
}
void appendOption(const char * const name, const FieldClass fc,
- const typename Option::RangeSet ranges)
+ const typename Option::RangeSet ranges) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc,
- const typename Option::RangeSet ranges)
+ const typename Option::RangeSet ranges) const
{
this->appendOption(name ? name->data() : nullptr, fc, ranges);
}
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())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
return *this;
}
- CommonBoolField<LibObjT>& operator=(const Value val) noexcept
+ CommonBoolField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
- CommonBitArrayField<LibObjT>& operator=(const std::uint64_t bits) noexcept
+ CommonBitArrayField<LibObjT> operator=(const std::uint64_t bits) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstIntegerFieldClass cls() const noexcept
- {
- return ConstIntegerFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
- CommonUnsignedIntegerField<LibObjT>& operator=(const Value val) noexcept
+ CommonUnsignedIntegerField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstIntegerFieldClass cls() const noexcept
- {
- return ConstIntegerFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
- CommonSignedIntegerField<LibObjT>& operator=(const Value val) noexcept
+ CommonSignedIntegerField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstUnsignedEnumerationFieldClass cls() const noexcept
- {
- return ConstUnsignedEnumerationFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
using CommonUnsignedIntegerField<LibObjT>::operator=;
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
using CommonSignedIntegerField<LibObjT>::operator=;
- ConstSignedEnumerationFieldClass cls() const noexcept
- {
- return ConstSignedEnumerationFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
return *this;
}
- CommonSinglePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
+ CommonSinglePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonDoublePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
+ CommonDoublePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonStringField<LibObjT>& operator=(const char * const val)
+ CommonStringField<LibObjT> operator=(const char * const val) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonStringField<LibObjT>& operator=(const std::string& val)
+ CommonStringField<LibObjT> operator=(const std::string& val) const
{
return *this = val.data();
}
- void append(const char * const begin, const std::uint64_t len)
+ void append(const char * const begin, const std::uint64_t len) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void append(const std::string& val)
+ void append(const std::string& val) const
{
this->append(val.data(), val.size());
}
- void clear() noexcept
+ void clear() const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstStructureFieldClass cls() const noexcept
- {
- return ConstStructureFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
return this->cls().size();
}
- ConstField operator[](const std::uint64_t index) const noexcept
- {
- return ConstField {internal::CommonStructureFieldSpec<const bt_field>::memberFieldByIndex(
- this->libObjPtr(), index)};
- }
-
- CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
+ CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
{
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);
-
- if (libObjPtr) {
- return ConstField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<ConstField> operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
- }
-
- nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) noexcept
+ nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) const noexcept
{
const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
return nonstd::nullopt;
}
- nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) noexcept
+ nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
{
return (*this)[name.data()];
}
return *this;
}
- ConstArrayFieldClass cls() const noexcept
- {
- return ConstArrayFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(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)};
- }
-
- CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
+ CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
{
return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
}
return _ThisCommonArrayField::length();
}
- void length(const std::uint64_t length)
+ void length(const std::uint64_t length) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstOptionFieldClass cls() const noexcept
- {
- return ConstOptionFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
- void hasField(const bool hasField) noexcept
+ void hasField(const bool hasField) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return this->field().has_value();
}
- nonstd::optional<ConstField> field() const noexcept
- {
- const auto libObjPtr =
- internal::CommonOptionFieldSpec<const bt_field>::field(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<CommonField<LibObjT>> field() noexcept
+ nonstd::optional<CommonField<LibObjT>> field() const noexcept
{
const auto libObjPtr = _Spec::field(this->libObjPtr());
return *this;
}
- ConstVariantFieldClass cls() const noexcept
- {
- return ConstVariantFieldClass {
- internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
- }
-
- Class cls() noexcept
+ Class cls() const noexcept
{
return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
}
- void selectOption(const std::uint64_t index) noexcept
+ void selectOption(const std::uint64_t index) const 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));
}
- ConstField selectedOptionField() const noexcept
- {
- return ConstField {internal::CommonVariantFieldSpec<const bt_field>::selectedOptionField(
- this->libObjPtr())};
- }
-
- CommonField<LibObjT> selectedOptionField() noexcept
+ CommonField<LibObjT> selectedOptionField() const noexcept
{
return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
}
return !(*this == other);
}
- void addRange(const Value lower, const Value upper)
+ void addRange(const Value lower, const Value upper) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstStream stream() const noexcept
- {
- return ConstStream {internal::CommonStreamBeginningMessageSpec<const bt_message>::stream(
- this->libObjPtr())};
- }
-
- _Stream stream() noexcept
+ _Stream stream() const noexcept
{
return _Stream {
internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->libObjPtr())};
}
- void defaultClockSnapshot(const std::uint64_t val) noexcept
+ void defaultClockSnapshot(const std::uint64_t val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstStream stream() const noexcept
- {
- return ConstStream {
- internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->libObjPtr())};
- }
-
- _Stream stream() noexcept
+ _Stream stream() const noexcept
{
return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->libObjPtr())};
}
- void defaultClockSnapshot(const std::uint64_t val) noexcept
+ void defaultClockSnapshot(const std::uint64_t val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstPacket packet() const noexcept
- {
- return ConstPacket {internal::CommonPacketBeginningMessageSpec<const bt_message>::packet(
- this->libObjPtr())};
- }
-
- _Packet packet() noexcept
+ _Packet packet() const noexcept
{
return _Packet {
internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->libObjPtr())};
}
- void defaultClockSnapshot(const std::uint64_t val) noexcept
+ void defaultClockSnapshot(const std::uint64_t val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstPacket packet() const noexcept
- {
- return ConstPacket {
- internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->libObjPtr())};
- }
-
- _Packet packet() noexcept
+ _Packet packet() const noexcept
{
return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->libObjPtr())};
}
- void defaultClockSnapshot(const std::uint64_t val) noexcept
+ void defaultClockSnapshot(const std::uint64_t val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstEvent event() const noexcept
- {
- return ConstEvent {
- internal::CommonEventMessageSpec<const bt_message>::event(this->libObjPtr())};
- }
-
- _Event event() noexcept
+ _Event event() const noexcept
{
return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
}
return *this;
}
- ConstStream stream() const noexcept
- {
- return ConstStream {internal::CommonDiscardedEventsMessageSpec<const bt_message>::stream(
- this->libObjPtr())};
- }
-
- _Stream stream() noexcept
+ _Stream stream() const noexcept
{
return _Stream {
internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
return ConstClockSnapshot {libObjPtr};
}
- void count(const std::uint64_t count) noexcept
+ void count(const std::uint64_t count) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- ConstStream stream() const noexcept
- {
- return ConstStream {internal::CommonDiscardedPacketsMessageSpec<const bt_message>::stream(
- this->libObjPtr())};
- }
-
- _Stream stream() noexcept
+ _Stream stream() const noexcept
{
return _Stream {
internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
return ConstClockSnapshot {libObjPtr};
}
- void count(const std::uint64_t count) noexcept
+ void count(const std::uint64_t count) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonEventSpec<const bt_event>;
using _Spec = internal::CommonEventSpec<LibObjT>;
using _Packet =
return *this;
}
- CommonEventClass<const bt_event_class> cls() const noexcept;
- Class cls() noexcept;
- CommonStream<const bt_stream> stream() const noexcept;
- _Stream stream() noexcept;
- nonstd::optional<CommonPacket<const bt_packet>> packet() const noexcept;
- nonstd::optional<_Packet> packet() noexcept;
+ Class cls() const noexcept;
+ _Stream stream() const noexcept;
+ nonstd::optional<_Packet> packet() const noexcept;
- nonstd::optional<ConstStructureField> payloadField() const noexcept
- {
- const auto libObjPtr = _ConstSpec::payloadField(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureField> payloadField() noexcept
+ nonstd::optional<_StructureField> payloadField() const noexcept
{
const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
return nonstd::nullopt;
}
- nonstd::optional<ConstStructureField> specificContextField() const noexcept
- {
- const auto libObjPtr = _ConstSpec::specificContextField(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureField> specificContextField() noexcept
+ nonstd::optional<_StructureField> specificContextField() const noexcept
{
const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
return nonstd::nullopt;
}
- nonstd::optional<ConstStructureField> commonContextField() const noexcept
- {
- const auto libObjPtr = _ConstSpec::commonContextField(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureField> commonContextField() noexcept
+ nonstd::optional<_StructureField> commonContextField() const noexcept
{
const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonPacketSpec<const bt_packet>;
using _Spec = internal::CommonPacketSpec<LibObjT>;
using _ThisCommonPacket = CommonPacket<LibObjT>;
return *this;
}
- CommonStream<const bt_stream> stream() const noexcept;
- _Stream stream() noexcept;
-
- nonstd::optional<ConstStructureField> contextField() const noexcept
- {
- const auto libObjPtr = _ConstSpec::contextField(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureField {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
+ _Stream stream() const noexcept;
- nonstd::optional<_StructureField> contextField() noexcept
+ nonstd::optional<_StructureField> contextField() const noexcept
{
const auto libObjPtr = _Spec::contextField(this->libObjPtr());
} /* namespace internal */
template <typename LibObjT>
-nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
-{
- const auto libObjPtr = _ConstSpec::packet(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstPacket {libObjPtr};
- }
-
- return nonstd::nullopt;
-}
-
-template <typename LibObjT>
-nonstd::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() noexcept
+nonstd::optional<typename CommonEvent<LibObjT>::_Packet>
+CommonEvent<LibObjT>::packet() const noexcept
{
const auto libObjPtr = _Spec::packet(this->libObjPtr());
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonStreamSpec<const bt_stream>;
using _Spec = internal::CommonStreamSpec<LibObjT>;
using _ThisCommonStream = CommonStream<LibObjT>;
return *this;
}
- Packet::Shared createPacket()
+ Packet::Shared createPacket() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return Packet::Shared::createWithoutRef(libObjPtr);
}
- CommonStreamClass<const bt_stream_class> cls() const noexcept;
- Class cls() noexcept;
- CommonTrace<const bt_trace> trace() const noexcept;
- _Trace trace() noexcept;
+ Class cls() const noexcept;
+ _Trace trace() const noexcept;
std::uint64_t id() const noexcept
{
return bt_stream_get_id(this->libObjPtr());
}
- void name(const char * const name)
+ void name(const char * const name) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void name(const std::string& name)
+ void name(const std::string& name) const
{
this->name(name.data());
}
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
} /* namespace internal */
template <typename LibObjT>
-ConstStream CommonEvent<LibObjT>::stream() const noexcept
-{
- return ConstStream {_ConstSpec::stream(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() noexcept
+typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
{
return _Stream {_Spec::stream(this->libObjPtr())};
}
template <typename LibObjT>
-ConstStream CommonPacket<LibObjT>::stream() const noexcept
-{
- return ConstStream {_ConstSpec::stream(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() noexcept
+typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
{
return _Stream {_Spec::stream(this->libObjPtr())};
}
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonTraceSpec<const bt_trace>;
using _Spec = internal::CommonTraceSpec<LibObjT>;
using _ThisCommonTrace = CommonTrace<LibObjT>;
return *this;
}
- CommonTraceClass<const bt_trace_class> cls() const noexcept;
- Class cls() noexcept;
+ Class cls() const noexcept;
- void name(const char * const name)
+ void name(const char * const name) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void name(const std::string& name)
+ void name(const std::string& name) const
{
this->name(name.data());
}
return nonstd::nullopt;
}
- void uuid(const bt2_common::UuidView& uuid) noexcept
+ void uuid(const bt2_common::UuidView& uuid) const noexcept
{
bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
}
return bt_trace_get_stream_count(this->libObjPtr());
}
- ConstStream operator[](const std::uint64_t index) const noexcept
- {
- return ConstStream {_ConstSpec::streamByIndex(this->libObjPtr(), index)};
- }
-
- _Stream operator[](const std::uint64_t index) noexcept
+ _Stream operator[](const std::uint64_t index) const noexcept
{
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);
-
- if (libObjPtr) {
- return ConstStream {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_Stream> streamById(const std::uint64_t id) noexcept
+ nonstd::optional<_Stream> streamById(const std::uint64_t id) const noexcept
{
const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
return nonstd::nullopt;
}
- void environmentEntry(const char * const name, const std::int64_t val)
+ void environmentEntry(const char * const name, const std::int64_t val) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void environmentEntry(const std::string& name, const std::int64_t val)
+ void environmentEntry(const std::string& name, const std::int64_t val) const
{
this->environmentEntry(name.data(), val);
}
- void environmentEntry(const char * const name, const char * const val)
+ void environmentEntry(const char * const name, const char * const val) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void environmentEntry(const std::string& name, const char * const val)
+ void environmentEntry(const std::string& name, const char * const val) const
{
this->environmentEntry(name.data(), val);
}
- void environmentEntry(const char * const name, const std::string& val)
+ void environmentEntry(const char * const name, const std::string& val) const
{
this->environmentEntry(name, val.data());
}
- void environmentEntry(const std::string& name, const std::string& val)
+ void environmentEntry(const std::string& name, const std::string& val) const
{
this->environmentEntry(name.data(), val.data());
}
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
} /* namespace internal */
template <typename LibObjT>
-ConstTrace CommonStream<LibObjT>::trace() const noexcept
-{
- return ConstTrace {_ConstSpec::trace(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() noexcept
+typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
{
return _Trace {_Spec::trace(this->libObjPtr())};
}
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonEventClassSpec<const bt_event_class>;
using _Spec = internal::CommonEventClassSpec<LibObjT>;
using _ThisCommonEventClass = CommonEventClass<LibObjT>;
return *this;
}
- CommonStreamClass<const bt_stream_class> streamClass() const noexcept;
- _StreamClass streamClass() noexcept;
+ _StreamClass streamClass() const noexcept;
std::uint64_t id() const noexcept
{
return bt_event_class_get_id(this->libObjPtr());
}
- void name(const char * const name)
+ void name(const char * const name) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void name(const std::string& name)
+ void name(const std::string& name) const
{
this->name(name.data());
}
return nonstd::nullopt;
}
- void logLevel(const LogLevel logLevel) noexcept
+ void logLevel(const LogLevel logLevel) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return nonstd::nullopt;
}
- void emfUri(const char * const emfUri)
+ void emfUri(const char * const emfUri) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void emfUri(const std::string& emfUri)
+ void emfUri(const std::string& emfUri) const
{
this->emfUri(emfUri.data());
}
return nonstd::nullopt;
}
- void payloadFieldClass(const StructureFieldClass fc)
+ void payloadFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- nonstd::optional<ConstStructureFieldClass> payloadFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::payloadFieldClass(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureFieldClass> payloadFieldClass() noexcept
+ nonstd::optional<_StructureFieldClass> payloadFieldClass() const noexcept
{
const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
return nonstd::nullopt;
}
- void specificContextFieldClass(const StructureFieldClass fc)
+ void specificContextFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- nonstd::optional<ConstStructureFieldClass> specificContextFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::specificContextFieldClass(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureFieldClass> specificContextFieldClass() noexcept
+ nonstd::optional<_StructureFieldClass> specificContextFieldClass() const noexcept
{
const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
} /* namespace internal */
template <typename LibObjT>
-ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
-{
- return ConstEventClass {_ConstSpec::cls(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() noexcept
+typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
{
return Class {_Spec::cls(this->libObjPtr())};
}
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonStreamClassSpec<const bt_stream_class>;
using _Spec = internal::CommonStreamClassSpec<LibObjT>;
using _ThisCommonStreamClass = CommonStreamClass<LibObjT>;
return *this;
}
- Stream::Shared instantiate(const Trace trace)
+ Stream::Shared instantiate(const Trace trace) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return Stream::Shared::createWithoutRef(libObjPtr);
}
- Stream::Shared instantiate(const Trace trace, const std::uint64_t id)
+ Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return Stream::Shared::createWithoutRef(libObjPtr);
}
- EventClass::Shared createEventClass()
+ EventClass::Shared createEventClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return EventClass::Shared::createWithoutRef(libObjPtr);
}
- EventClass::Shared createEventClass(const std::uint64_t id)
+ EventClass::Shared createEventClass(const std::uint64_t id) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return EventClass::Shared::createWithoutRef(libObjPtr);
}
- CommonTraceClass<const bt_trace_class> traceClass() const noexcept;
- _TraceClass traceClass() noexcept;
+ _TraceClass traceClass() const noexcept;
std::uint64_t id() const noexcept
{
return bt_stream_class_get_id(this->libObjPtr());
}
- void name(const char * const name)
+ void name(const char * const name) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void name(const std::string& name)
+ void name(const std::string& name) const
{
this->name(name.data());
}
return nonstd::nullopt;
}
- void assignsAutomaticEventClassId(const bool val) noexcept
+ void assignsAutomaticEventClassId(const bool val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
}
- void assignsAutomaticStreamId(const bool val) noexcept
+ void assignsAutomaticStreamId(const bool val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
- const bool withEndDefaultClkSnapshot) noexcept
+ const bool withEndDefaultClkSnapshot) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
void supportsDiscardedEvents(const bool supportsDiscardedEvents,
- const bool withDefaultClkSnapshots) noexcept
+ const bool withDefaultClkSnapshots) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
void supportsDiscardedPackets(const bool supportsDiscardedPackets,
- const bool withDefaultClkSnapshots) noexcept
+ const bool withDefaultClkSnapshots) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
}
- void defaultClockClass(const ClockClass clkCls)
+ void defaultClockClass(const ClockClass clkCls) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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());
-
- if (libObjPtr) {
- return ConstClockClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_ClockClass> defaultClockClass() noexcept
+ nonstd::optional<_ClockClass> defaultClockClass() const noexcept
{
const auto libObjPtr = _Spec::defaultClockClass(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)};
- }
-
- _EventClass operator[](const std::uint64_t index) noexcept
+ _EventClass operator[](const std::uint64_t index) const noexcept
{
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);
-
- if (libObjPtr) {
- return ConstEventClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) noexcept
+ nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) const noexcept
{
const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
return nonstd::nullopt;
}
- void packetContextFieldClass(const StructureFieldClass fc)
+ void packetContextFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- nonstd::optional<ConstStructureFieldClass> packetContextFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureFieldClass> packetContextFieldClass() noexcept
+ nonstd::optional<_StructureFieldClass> packetContextFieldClass() const noexcept
{
const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
return nonstd::nullopt;
}
- void eventCommonContextFieldClass(const StructureFieldClass fc)
+ void eventCommonContextFieldClass(const StructureFieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- nonstd::optional<ConstStructureFieldClass> eventCommonContextFieldClass() const noexcept
- {
- const auto libObjPtr = _ConstSpec::eventCommonContextFieldClass(this->libObjPtr());
-
- if (libObjPtr) {
- return ConstStructureFieldClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() noexcept
+ nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
{
const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
} /* namespace internal */
template <typename LibObjT>
-ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
-{
- return ConstStreamClass {_ConstSpec::streamClass(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonEventClass<LibObjT>::_StreamClass CommonEventClass<LibObjT>::streamClass() noexcept
+typename CommonEventClass<LibObjT>::_StreamClass
+CommonEventClass<LibObjT>::streamClass() const noexcept
{
return _StreamClass {_Spec::streamClass(this->libObjPtr())};
}
template <typename LibObjT>
-ConstStreamClass CommonStream<LibObjT>::cls() const noexcept
-{
- return ConstStreamClass {_ConstSpec::cls(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() noexcept
+typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
{
return Class {_Spec::cls(this->libObjPtr())};
}
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
- using _ConstSpec = internal::CommonTraceClassSpec<const bt_trace_class>;
using _Spec = internal::CommonTraceClassSpec<LibObjT>;
using _ThisCommonTraceClass = CommonTraceClass<LibObjT>;
return *this;
}
- Trace::Shared instantiate()
+ Trace::Shared instantiate() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return Trace::Shared::createWithoutRef(libObjPtr);
}
- StreamClass::Shared createStreamClass()
+ StreamClass::Shared createStreamClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return StreamClass::Shared::createWithoutRef(libObjPtr);
}
- StreamClass::Shared createStreamClass(const std::uint64_t id)
+ StreamClass::Shared createStreamClass(const std::uint64_t id) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return StreamClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createBoolFieldClass()
+ FieldClass::Shared createBoolFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length)
+ BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
}
- IntegerFieldClass::Shared createUnsignedIntegerFieldClass()
+ IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
}
- IntegerFieldClass::Shared createSignedIntegerFieldClass()
+ IntegerFieldClass::Shared createSignedIntegerFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
}
- UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass()
+ UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
}
- SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass()
+ SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createSinglePrecisionRealFieldClass()
+ FieldClass::Shared createSinglePrecisionRealFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createDoublePrecisionRealFieldClass()
+ FieldClass::Shared createDoublePrecisionRealFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- FieldClass::Shared createStringFieldClass()
+ FieldClass::Shared createStringFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
- const std::uint64_t length)
+ const std::uint64_t length) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
}
- ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass)
+ ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
DynamicArrayWithLengthFieldClass::Shared
createDynamicArrayFieldClass(const FieldClass elementFieldClass,
- const IntegerFieldClass lengthFieldClass)
+ const IntegerFieldClass lengthFieldClass) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
}
- StructureFieldClass::Shared createStructureFieldClass()
+ StructureFieldClass::Shared createStructureFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
}
- OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass)
+ OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
OptionWithBoolSelectorFieldClass::Shared
createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
- const FieldClass selectorFieldClass)
+ const FieldClass selectorFieldClass) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
OptionWithUnsignedIntegerSelectorFieldClass::Shared
- createOptionWithUnsignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
- const IntegerFieldClass selectorFieldClass,
- const ConstUnsignedIntegerRangeSet ranges)
+ createOptionWithUnsignedIntegerSelectorFieldClass(
+ const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
+ const ConstUnsignedIntegerRangeSet ranges) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
OptionWithSignedIntegerSelectorFieldClass::Shared
createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
const IntegerFieldClass selectorFieldClass,
- const ConstSignedIntegerRangeSet ranges)
+ const ConstSignedIntegerRangeSet ranges) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
}
- VariantWithoutSelectorFieldClass::Shared createVariantFieldClass()
+ VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
VariantWithUnsignedIntegerSelectorFieldClass::Shared
- createVariantWithUnsignedIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
+ createVariantWithUnsignedIntegerSelectorFieldClass(
+ const IntegerFieldClass selectorFieldClass) const
{
return this->_createVariantWithIntegerSelectorFieldClass<
VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
}
VariantWithSignedIntegerSelectorFieldClass::Shared
- createVariantWithSignedIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
+ createVariantWithSignedIntegerSelectorFieldClass(
+ const IntegerFieldClass selectorFieldClass) const
{
return this->_createVariantWithIntegerSelectorFieldClass<
VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
}
- void assignsAutomaticStreamClassId(const bool val) noexcept
+ void assignsAutomaticStreamClassId(const bool val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
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)};
- }
-
- _StreamClass operator[](const std::uint64_t index) noexcept
+ _StreamClass operator[](const std::uint64_t index) const noexcept
{
return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<ConstStreamClass> streamClassById(const std::uint64_t id) const noexcept
- {
- const auto libObjPtr = _ConstSpec::streamClassById(this->libObjPtr(), id);
-
- if (libObjPtr) {
- return ConstStreamClass {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) noexcept
+ nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
{
const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
}
private:
template <typename ObjT>
typename ObjT::Shared
- _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
+ _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
} /* namespace internal */
template <typename LibObjT>
-ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
-{
- return ConstTraceClass {_ConstSpec::traceClass(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonStreamClass<LibObjT>::_TraceClass CommonStreamClass<LibObjT>::traceClass() noexcept
+typename CommonStreamClass<LibObjT>::_TraceClass
+CommonStreamClass<LibObjT>::traceClass() const noexcept
{
return _TraceClass {_Spec::traceClass(this->libObjPtr())};
}
template <typename LibObjT>
-ConstTraceClass CommonTrace<LibObjT>::cls() const noexcept
-{
- return ConstTraceClass {_ConstSpec::cls(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() noexcept
+typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
{
return Class {_Spec::cls(this->libObjPtr())};
}
return *this;
}
- CommonBoolValue<LibObjT>& operator=(const Value rawVal) noexcept
+ CommonBoolValue<LibObjT> operator=(const Value rawVal) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonUnsignedIntegerValue<LibObjT>& operator=(const Value rawVal) noexcept
+ CommonUnsignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
{
bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
return *this;
}
template <typename OtherLibObjT>
- CommonSignedIntegerValue<LibObjT>&
+ CommonSignedIntegerValue<LibObjT>
operator=(const CommonSignedIntegerValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
- CommonSignedIntegerValue<LibObjT>& operator=(const Value rawVal) noexcept
+ CommonSignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonRealValue<LibObjT>& operator=(const Value rawVal) noexcept
+ CommonRealValue<LibObjT> operator=(const Value rawVal) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonStringValue<LibObjT>& operator=(const char * const rawVal)
+ CommonStringValue<LibObjT> operator=(const char * const rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return *this;
}
- CommonStringValue<LibObjT>& operator=(const std::string& rawVal) noexcept
+ CommonStringValue<LibObjT> operator=(const std::string& rawVal) const noexcept
{
return *this = rawVal.data();
}
return this->length() == 0;
}
- ConstValue operator[](const std::uint64_t index) const noexcept
- {
- return ConstValue {internal::CommonArrayValueSpec<const bt_value>::elementByIndex(
- this->libObjPtr(), index)};
- }
-
- CommonValue<LibObjT> operator[](const std::uint64_t index) noexcept
+ CommonValue<LibObjT> operator[](const std::uint64_t index) const noexcept
{
return CommonValue<LibObjT> {
internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
}
- void append(const Value val)
+ void append(const Value val) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleAppendLibStatus(status);
}
- void append(const bool rawVal)
+ void append(const bool rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleAppendLibStatus(status);
}
- void append(const std::uint64_t rawVal)
+ void append(const std::uint64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleAppendLibStatus(status);
}
- void append(const std::int64_t rawVal)
+ void append(const std::int64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleAppendLibStatus(status);
}
- void append(const double rawVal)
+ void append(const double rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleAppendLibStatus(status);
}
- void append(const char * const rawVal)
+ void append(const char * const rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleAppendLibStatus(status);
}
- void append(const std::string& rawVal)
+ void append(const std::string& rawVal) const
{
this->append(rawVal.data());
}
- CommonArrayValue<bt_value> appendEmptyArray();
- CommonMapValue<bt_value> appendEmptyMap();
+ CommonArrayValue<bt_value> appendEmptyArray() const;
+ CommonMapValue<bt_value> appendEmptyMap() const;
- void operator+=(const Value val)
+ void operator+=(const Value val) const
{
this->append(val);
}
- void operator+=(const bool rawVal)
+ void operator+=(const bool rawVal) const
{
this->append(rawVal);
}
- void operator+=(const std::uint64_t rawVal)
+ void operator+=(const std::uint64_t rawVal) const
{
this->append(rawVal);
}
- void operator+=(const std::int64_t rawVal)
+ void operator+=(const std::int64_t rawVal) const
{
this->append(rawVal);
}
- void operator+=(const double rawVal)
+ void operator+=(const double rawVal) const
{
this->append(rawVal);
}
- void operator+=(const char * const rawVal)
+ void operator+=(const char * const rawVal) const
{
this->append(rawVal);
}
- void operator+=(const std::string& rawVal)
+ void operator+=(const std::string& rawVal) const
{
this->append(rawVal);
}
return this->size() == 0;
}
- nonstd::optional<ConstValue> operator[](const char * const key) const noexcept
- {
- const auto libObjPtr =
- internal::CommonMapValueSpec<const bt_value>::entryByKey(this->libObjPtr(), key);
-
- if (!libObjPtr) {
- return nonstd::nullopt;
- }
-
- return ConstValue {libObjPtr};
- }
-
- nonstd::optional<ConstValue> operator[](const std::string& key) const noexcept
- {
- return (*this)[key.data()];
- }
-
- nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) noexcept
+ nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) const noexcept
{
const auto libObjPtr =
internal::CommonMapValueSpec<LibObjT>::entryByKey(this->libObjPtr(), key);
return CommonValue<LibObjT> {libObjPtr};
}
- nonstd::optional<CommonValue<LibObjT>> operator[](const std::string& key) noexcept
+ nonstd::optional<CommonValue<LibObjT>> operator[](const std::string& key) const noexcept
{
return (*this)[key.data()];
}
return this->hasEntry(key.data());
}
- void insert(const char * const key, const Value val)
+ void insert(const char * const key, const Value val) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const std::string& key, const Value val)
+ void insert(const std::string& key, const Value val) const
{
this->insert(key.data(), val);
}
- void insert(const char * const key, const bool rawVal)
+ void insert(const char * const key, const bool rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const std::string& key, const bool rawVal)
+ void insert(const std::string& key, const bool rawVal) const
{
this->insert(key.data(), rawVal);
}
- void insert(const char * const key, const std::uint64_t rawVal)
+ void insert(const char * const key, const std::uint64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const std::string& key, const std::uint64_t rawVal)
+ void insert(const std::string& key, const std::uint64_t rawVal) const
{
this->insert(key.data(), rawVal);
}
- void insert(const char * const key, const std::int64_t rawVal)
+ void insert(const char * const key, const std::int64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const std::string& key, const std::int64_t rawVal)
+ void insert(const std::string& key, const std::int64_t rawVal) const
{
this->insert(key.data(), rawVal);
}
- void insert(const char * const key, const double rawVal)
+ void insert(const char * const key, const double rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const std::string& key, const double rawVal)
+ void insert(const std::string& key, const double rawVal) const
{
this->insert(key.data(), rawVal);
}
- void insert(const char * const key, const char * const rawVal)
+ void insert(const char * const key, const char * const rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const char * const key, const std::string& rawVal)
+ void insert(const char * const key, const std::string& rawVal) const
{
this->insert(key, rawVal.data());
}
- void insert(const std::string& key, const char * const rawVal)
+ void insert(const std::string& key, const char * const rawVal) const
{
this->insert(key.data(), rawVal);
}
- void insert(const std::string& key, const std::string& rawVal)
+ void insert(const std::string& key, const std::string& rawVal) const
{
this->insert(key.data(), rawVal.data());
}
- CommonArrayValue<bt_value> insertEmptyArray(const char *key);
- CommonArrayValue<bt_value> insertEmptyArray(const std::string& key);
- CommonMapValue<bt_value> insertEmptyMap(const char *key);
- CommonMapValue<bt_value> insertEmptyMap(const std::string& key);
-
- void forEach(const internal::CommonMapValueForEachUserFunc<ConstValue>& func) const
- {
- internal::CommonMapValueSpec<const bt_value>::forEach(this->libObjPtr(), func);
- }
+ CommonArrayValue<bt_value> insertEmptyArray(const char *key) const;
+ CommonArrayValue<bt_value> insertEmptyArray(const std::string& key) const;
+ CommonMapValue<bt_value> insertEmptyMap(const char *key) const;
+ CommonMapValue<bt_value> insertEmptyMap(const std::string& key) const;
- void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func)
+ void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func) const
{
internal::CommonMapValueSpec<LibObjT>::forEach(this->libObjPtr(), func);
}
}
template <typename LibObjT>
-ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray()
+ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename LibObjT>
-MapValue CommonArrayValue<LibObjT>::appendEmptyMap()
+MapValue CommonArrayValue<LibObjT>::appendEmptyMap() const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename LibObjT>
-ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key)
+ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename LibObjT>
-ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const std::string& key)
+ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const std::string& key) const
{
return this->insertEmptyArray(key.data());
}
template <typename LibObjT>
-MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key)
+MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key) const
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename LibObjT>
-MapValue CommonMapValue<LibObjT>::insertEmptyMap(const std::string& key)
+MapValue CommonMapValue<LibObjT>::insertEmptyMap(const std::string& key) const
{
return this->insertEmptyMap(key.data());
}