#include <babeltrace2/babeltrace.h>
#include "common/assert.h"
-#include "cpp-common/optional.hpp"
-#include "cpp-common/string_view.hpp"
+#include "cpp-common/bt2c/c-string-view.hpp"
+#include "cpp-common/bt2s/optional.hpp"
#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
#include "field-path.hpp"
#include "integer-range-set.hpp"
#include "internal/utils.hpp"
+#include "optional-borrowed-object.hpp"
#include "shared-object.hpp"
#include "value.hpp"
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
protected:
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
- explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
+ explicit CommonFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
}
template <typename OtherLibObjT>
- CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
+ CommonFieldClass operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return *this;
class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
{
private:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
- explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonBitArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isBitArray());
}
template <typename OtherLibObjT>
- CommonBitArrayFieldClass<LibObjT>&
+ CommonBitArrayFieldClass<LibObjT>
operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
- explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonIntegerFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isInteger());
}
template <typename OtherLibObjT>
- CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
+ CommonIntegerFieldClass operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
{
};
-} /* namespace internal */
-
-namespace internal {
-
template <typename LibObjT>
struct ConstEnumerationFieldClassMappingSpec;
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+
using RangeSet = typename std::conditional<
std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
- explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
+ explicit ConstEnumerationFieldClassMapping(const LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
{
}
{
}
- ConstEnumerationFieldClassMapping&
+ ConstEnumerationFieldClassMapping
operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
{
_ThisBorrowedObject::operator=(mapping);
internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
}
- bpstd::string_view label() const noexcept
+ bt2c::CStringView label() const noexcept
{
return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
}
using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
- explicit CommonBaseEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonBaseEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonIntegerFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isEnumeration());
}
template <typename OtherLibObjT>
- CommonBaseEnumerationFieldClass&
+ CommonBaseEnumerationFieldClass
operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonIntegerFieldClass::operator=(fc);
class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass<LibObjT>
{
private:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
- using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
public:
- using Shared = SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
+ using Shared = SharedFieldClass<CommonEnumerationFieldClass, LibObjT>;
using Iterator = BorrowedObjectIterator<CommonEnumerationFieldClass>;
using Mapping = MappingT;
- explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonBaseEnumerationFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isEnumeration());
template <typename OtherLibObjT>
CommonEnumerationFieldClass(
const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
- _ThisCommonEnumerationFieldClass {fc}
+ CommonEnumerationFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonEnumerationFieldClass&
+ CommonEnumerationFieldClass
operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
{
- _ThisCommonEnumerationFieldClass::operator=(fc);
+ CommonEnumerationFieldClass::operator=(fc);
return *this;
}
this->libObjPtr(), index)};
}
- nonstd::optional<Mapping> operator[](const char * const label) const noexcept
+ OptionalBorrowedObject<Mapping> operator[](const bt2c::CStringView label) const noexcept
{
- const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
+ return internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
this->libObjPtr(), label);
-
- if (libObjPtr) {
- return Mapping {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
- {
- return (*this)[label.data()];
}
- void addMapping(const char * const label, const typename Mapping::RangeSet ranges) const
+ void addMapping(const bt2c::CStringView 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) const
- {
- this->addMapping(label.data(), ranges);
- }
-
Iterator begin() const noexcept
{
return Iterator {*this, 0};
class CommonStructureFieldClassMember final : public BorrowedObject<LibObjT>
{
private:
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using _FieldClass = internal::DepFc<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
- explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonStructureFieldClassMember(const LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
{
}
}
template <typename OtherLibObjT>
- CommonStructureFieldClassMember<LibObjT>&
+ CommonStructureFieldClassMember<LibObjT>
operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return CommonStructureFieldClassMember<const bt_field_class_structure_member> {*this};
}
- bpstd::string_view name() const noexcept
+ bt2c::CStringView name() const noexcept
{
return bt_field_class_structure_member_get_name(this->libObjPtr());
}
class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
{
private:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
using Iterator = BorrowedObjectIterator<CommonStructureFieldClass<LibObjT>>;
using Member =
internal::DepType<LibObjT, StructureFieldClassMember, ConstStructureFieldClassMember>;
- explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonStructureFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isStructure());
}
template <typename OtherLibObjT>
- CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
+ CommonStructureFieldClass operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
return CommonStructureFieldClass<const bt_field_class> {*this};
}
- void appendMember(const char * const name, const FieldClass fc) const
+ void appendMember(const bt2c::CStringView name, const FieldClass fc) const
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStructureFieldClass`.");
}
}
- void appendMember(const std::string& name, const FieldClass fc) const
- {
- this->appendMember(name.data(), fc);
- }
-
std::uint64_t length() const noexcept
{
return bt_field_class_structure_get_member_count(this->libObjPtr());
this->libObjPtr(), index)};
}
- nonstd::optional<Member> operator[](const char * const name) const noexcept
+ OptionalBorrowedObject<Member> operator[](const bt2c::CStringView name) const noexcept
{
- const auto libObjPtr =
- internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
-
- if (libObjPtr) {
- return Member {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<Member> operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
+ return internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(),
+ name);
}
Shared shared() const noexcept
using _FieldClass = internal::DepFc<LibObjT>;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
- explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isArray());
}
template <typename OtherLibObjT>
- CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
+ CommonArrayFieldClass operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
{
private:
using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
- explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonStaticArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonArrayFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isStaticArray());
}
template <typename OtherLibObjT>
- CommonStaticArrayFieldClass&
+ CommonStaticArrayFieldClass
operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonArrayFieldClass::operator=(fc);
{
private:
using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
- explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonDynamicArrayWithLengthFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonArrayFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isDynamicArrayWithLength());
}
template <typename OtherLibObjT>
- CommonDynamicArrayWithLengthFieldClass&
+ CommonDynamicArrayWithLengthFieldClass
operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonArrayFieldClass::operator=(fc);
using _FieldClass = internal::DepFc<LibObjT>;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
- explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonOptionFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isOption());
}
template <typename OtherLibObjT>
- CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
+ CommonOptionFieldClass operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
- explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonOptionWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonOptionFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isOptionWithSelector());
}
template <typename OtherLibObjT>
- CommonOptionWithSelectorFieldClass&
+ CommonOptionWithSelectorFieldClass
operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonOptionFieldClass::operator=(fc);
class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
{
private:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
-
using typename CommonOptionWithSelectorFieldClass<
LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
- explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonOptionWithBoolSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonOptionWithSelectorFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isOptionWithBoolSelector());
}
template <typename OtherLibObjT>
- CommonOptionWithBoolSelectorFieldClass&
+ CommonOptionWithBoolSelectorFieldClass
operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonOptionWithSelectorFieldClass::operator=(fc);
class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
{
private:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
-
using typename CommonOptionWithSelectorFieldClass<
LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
- using _ThisCommonOptionWithIntegerSelectorFieldClass =
- CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
-
public:
- using Shared = SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
-
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
+ using Shared = SharedFieldClass<CommonOptionWithIntegerSelectorFieldClass, LibObjT>;
using RangeSet = RangeSetT;
- explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonOptionWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonOptionWithSelectorFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
}
template <typename OtherLibObjT>
- CommonOptionWithIntegerSelectorFieldClass&
+ CommonOptionWithIntegerSelectorFieldClass
operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
{
_ThisCommonOptionWithSelectorFieldClass::operator=(fc);
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _FieldClass = internal::DepFc<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
- explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonVariantFieldClassOption(const LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
{
}
}
template <typename OtherLibObjT>
- CommonVariantFieldClassOption&
+ CommonVariantFieldClassOption
operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return CommonVariantFieldClassOption<const bt_field_class_variant_option> {*this};
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ bt2c::CStringView name() const noexcept
{
- const auto name = bt_field_class_variant_option_get_name(this->libObjPtr());
-
- if (name) {
- return name;
- }
-
- return nonstd::nullopt;
+ return bt_field_class_variant_option_get_name(this->libObjPtr());
}
_FieldClass fieldClass() const noexcept
{
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
- using typename BorrowedObject<LibObjT>::_LibObjPtr;
using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
public:
+ using typename BorrowedObject<LibObjT>::LibObjPtr;
+
using RangeSet = typename std::conditional<
std::is_same<
LibObjT,
const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
- explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
+ explicit ConstVariantWithIntegerSelectorFieldClassOption(const LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
{
}
}
template <typename OtherLibObjT>
- ConstVariantWithIntegerSelectorFieldClassOption&
+ ConstVariantWithIntegerSelectorFieldClassOption
operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ bt2c::CStringView name() const noexcept
{
return this->asBaseOption().name();
}
using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
using Iterator = BorrowedObjectIterator<CommonVariantFieldClass>;
using Option =
internal::DepType<LibObjT, VariantFieldClassOption, ConstVariantFieldClassOption>;
- explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonVariantFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isVariant());
}
template <typename OtherLibObjT>
- CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
+ CommonVariantFieldClass operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
this->libObjPtr(), index)};
}
- nonstd::optional<Option> operator[](const char * const name) const noexcept
+ OptionalBorrowedObject<Option> operator[](const bt2c::CStringView name) const noexcept
{
- const auto libObjPtr =
- internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
-
- if (libObjPtr) {
- return Option {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<Option> operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
+ return internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(),
+ name);
}
Shared shared() const noexcept
{
private:
using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
- explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonVariantWithoutSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonVariantFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isVariantWithoutSelector());
}
template <typename OtherLibObjT>
- CommonVariantWithoutSelectorFieldClass&
+ CommonVariantWithoutSelectorFieldClass
operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonVariantFieldClass::operator=(fc);
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc) const
+ void appendOption(const bt2c::CStringView name, const FieldClass fc) const
+ {
+ return this->appendOption(name.data(), fc);
+ }
+
+ void appendOption(const bt2s::optional<std::string>& name, const FieldClass fc) const
{
this->appendOption(name ? name->data() : nullptr, fc);
}
using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
protected:
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
public:
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
using Shared = SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
- explicit CommonVariantWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonVariantWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonVariantFieldClass {libObjPtr}
{
BT_ASSERT_DBG(this->isVariantWithSelector());
}
template <typename OtherLibObjT>
- CommonVariantWithSelectorFieldClass&
+ CommonVariantWithSelectorFieldClass
operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonVariantFieldClass::operator=(fc);
private:
using typename CommonVariantWithSelectorFieldClass<
LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
- using typename CommonFieldClass<LibObjT>::_LibObjPtr;
- using _ThisCommonVariantWithIntegerSelectorFieldClass =
- CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
public:
- using Shared = SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
-
+ using typename CommonFieldClass<LibObjT>::LibObjPtr;
+ using Shared = SharedFieldClass<CommonVariantWithIntegerSelectorFieldClass, LibObjT>;
using Option = OptionT;
using Iterator =
BorrowedObjectIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>>;
- explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+ explicit CommonVariantWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
_ThisCommonVariantWithSelectorFieldClass {libObjPtr}
{
- BT_ASSERT_DBG(this->isVariant());
+ BT_ASSERT_DBG(this->isVariantWithIntegerSelector());
}
template <typename OtherLibObjT>
}
template <typename OtherLibObjT>
- CommonVariantWithIntegerSelectorFieldClass&
+ CommonVariantWithIntegerSelectorFieldClass
operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
{
_ThisCommonVariantWithSelectorFieldClass::operator=(fc);
return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<Option> operator[](const char * const name) const noexcept
+ OptionalBorrowedObject<Option> operator[](const bt2c::CStringView name) const noexcept
{
- const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
-
- if (libObjPtr) {
- return Option {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<Option> operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
+ return _Spec::optionByName(this->libObjPtr(), name);
}
void appendOption(const char * const name, const FieldClass fc,
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc,
+ void appendOption(const bt2c::CStringView name, const FieldClass fc,
+ const typename Option::RangeSet ranges) const
+ {
+ return this->appendOption(name.data(), fc, ranges);
+ }
+
+ void appendOption(const bt2s::optional<std::string>& name, const FieldClass fc,
const typename Option::RangeSet ranges) const
{
this->appendOption(name ? name->data() : nullptr, fc, ranges);