X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcpp-common%2Fbt2%2Ffield-class.hpp;h=83cd52157cc4af723e6bc895817a52204e193cee;hb=1c5ea5eb3a9adbc3adc4a3a36a6cf09f7fa05bf1;hp=a248d9d1425d7c591419ad04a3ae5884f3b84745;hpb=b5f55e9f83cf782b3d423912cfffece103177fe1;p=babeltrace.git diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp index a248d9d1..83cd5215 100644 --- a/src/cpp-common/bt2/field-class.hpp +++ b/src/cpp-common/bt2/field-class.hpp @@ -7,39 +7,41 @@ #ifndef BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP #define BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP -#include #include +#include + #include #include "common/assert.h" -#include "internal/borrowed-obj.hpp" -#include "internal/shared-obj.hpp" -#include "cpp-common/optional.hpp" -#include "cpp-common/string_view.hpp" -#include "lib-error.hpp" -#include "integer-range-set.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 "exc.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" namespace bt2 { - namespace internal { struct FieldClassRefFuncs final { - static void get(const bt_field_class * const libObjPtr) + static void get(const bt_field_class * const libObjPtr) noexcept { bt_field_class_get_ref(libObjPtr); } - static void put(const bt_field_class * const libObjPtr) + static void put(const bt_field_class * const libObjPtr) noexcept { bt_field_class_put_ref(libObjPtr); } }; -template -using SharedFieldClass = internal::SharedObj; - template struct CommonFieldClassSpec; @@ -65,6 +67,9 @@ struct CommonFieldClassSpec final } /* namespace internal */ +template +using SharedFieldClass = SharedObject; + template class CommonBitArrayFieldClass; @@ -74,6 +79,9 @@ class CommonIntegerFieldClass; template class ConstEnumerationFieldClassMapping; +template +class CommonBaseEnumerationFieldClass; + template class CommonEnumerationFieldClass; @@ -107,6 +115,9 @@ class CommonOptionWithIntegerSelectorFieldClass; template class CommonVariantWithoutSelectorFieldClass; +template +class CommonVariantWithSelectorFieldClass; + template class ConstVariantWithIntegerSelectorFieldClassOption; @@ -124,90 +135,69 @@ class CommonTraceClass; enum class FieldClassType { - BOOL = BT_FIELD_CLASS_TYPE_BOOL, - BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY, - UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER, - SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER, - UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION, - SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION, - SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL, - DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL, - STRING = BT_FIELD_CLASS_TYPE_STRING, - STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE, - STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY, - DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD, - DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD, - OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD, - OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD, - OPTION_WITH_UNSIGNED_INTEGER_SELECTOR = + Bool = BT_FIELD_CLASS_TYPE_BOOL, + BitArray = BT_FIELD_CLASS_TYPE_BIT_ARRAY, + UnsignedInteger = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER, + SignedInteger = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER, + UnsignedEnumeration = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION, + SignedEnumeration = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION, + SinglePrecisionReal = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL, + DoublePrecisionReal = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL, + String = BT_FIELD_CLASS_TYPE_STRING, + Structure = BT_FIELD_CLASS_TYPE_STRUCTURE, + StaticArray = BT_FIELD_CLASS_TYPE_STATIC_ARRAY, + DynamicArrayWithoutLength = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD, + DynamicArrayWithLength = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD, + OptionWithoutSelector = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD, + OptionWithBoolSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD, + OptionWithUnsignedIntegerSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD, - OPTION_WITH_SIGNED_INTEGER_SELECTOR = - BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD, - VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD, - VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR = + OptionWithSignedIntegerSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD, + VariantWithoutSelector = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD, + VariantWithUnsignedIntegerSelector = BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD, - VARIANT_WITH_SIGNED_INTEGER_SELECTOR = + VariantWithSignedIntegerSelector = BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD, }; template -class CommonFieldClass : public internal::BorrowedObj +class CommonFieldClass : public BorrowedObject { - /* Allow appendMember() to call `fc._libObjPtr()` */ - friend class CommonStructureFieldClass; - - /* Allow appendOption() to call `fc._libObjPtr()` */ - friend class CommonVariantWithoutSelectorFieldClass; - - friend class CommonVariantWithIntegerSelectorFieldClass< - bt_field_class, - ConstVariantWithIntegerSelectorFieldClassOption< - const bt_field_class_variant_with_selector_field_integer_unsigned_option>>; - - friend class CommonVariantWithIntegerSelectorFieldClass< - bt_field_class, - ConstVariantWithIntegerSelectorFieldClassOption< - const bt_field_class_variant_with_selector_field_integer_signed_option>>; - - /* Allow *FieldClass() to call `fc._libObjPtr()` */ - friend class CommonEventClass; - friend class CommonStreamClass; - - /* Allow create*FieldClass() to call `fc._libObjPtr()` */ - friend class CommonTraceClass; - private: - using typename internal::BorrowedObj::_ThisBorrowedObj; + using typename BorrowedObject::_ThisBorrowedObject; protected: - using typename internal::BorrowedObj::_LibObjPtr; using _ThisCommonFieldClass = CommonFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; - - using UserAttributes = - typename std::conditional::value, ConstMapValue, MapValue>::type; + using typename BorrowedObject::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; + using UserAttributes = internal::DepUserAttrs; - explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr} + explicit CommonFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr} { } template - CommonFieldClass(const CommonFieldClass& fc) noexcept : _ThisBorrowedObj {fc} + CommonFieldClass(const CommonFieldClass fc) noexcept : _ThisBorrowedObject {fc} { } template - _ThisCommonFieldClass& operator=(const CommonFieldClass& fc) noexcept + CommonFieldClass operator=(const CommonFieldClass fc) noexcept { - _ThisBorrowedObj::operator=(fc); + _ThisBorrowedObject::operator=(fc); return *this; } + CommonFieldClass asConst() const noexcept + { + return CommonFieldClass {*this}; + } + FieldClassType type() const noexcept { - return static_cast(bt_field_class_get_type(this->_libObjPtr())); + return static_cast(bt_field_class_get_type(this->libObjPtr())); } bool isBool() const noexcept @@ -250,6 +240,11 @@ public: return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION); } + bool isReal() const noexcept + { + return this->_libTypeIs(BT_FIELD_CLASS_TYPE_REAL); + } + bool isSinglePrecisionReal() const noexcept { return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL); @@ -360,9 +355,15 @@ public: return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD); } + template + FieldClassT as() const noexcept + { + return FieldClassT {this->libObjPtr()}; + } + CommonBitArrayFieldClass asBitArray() const noexcept; CommonIntegerFieldClass asInteger() const noexcept; - + CommonBaseEnumerationFieldClass asEnumeration() const noexcept; CommonEnumerationFieldClass> asUnsignedEnumeration() const noexcept; @@ -387,6 +388,7 @@ public: CommonVariantFieldClass asVariant() const noexcept; CommonVariantWithoutSelectorFieldClass asVariantWithoutSelector() const noexcept; + CommonVariantWithSelectorFieldClass asVariantWithSelector() const noexcept; CommonVariantWithIntegerSelectorFieldClass< LibObjT, ConstVariantWithIntegerSelectorFieldClassOption< @@ -399,90 +401,130 @@ public: asVariantWithSignedIntegerSelector() const noexcept; template - void userAttributes(const CommonMapValue& userAttrs) + CommonFieldClass userAttributes(const CommonMapValue userAttrs) const noexcept { - static_assert(!std::is_const::value, "`LibObjT` must NOT be `const`."); + static_assert(!std::is_const::value, "Not available with `bt2::ConstFieldClass`."); - bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr()); - } - - ConstMapValue userAttributes() const noexcept - { - return ConstMapValue {internal::CommonFieldClassSpec::userAttributes( - this->_libObjPtr())}; + bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr()); + return *this; } - UserAttributes userAttributes() noexcept + UserAttributes userAttributes() const noexcept { return UserAttributes { - internal::CommonFieldClassSpec::userAttributes(this->_libObjPtr())}; + internal::CommonFieldClassSpec::userAttributes(this->libObjPtr())}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } protected: bool _libTypeIs(const bt_field_class_type type) const noexcept { - return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type); + return bt_field_class_type_is(bt_field_class_get_type(this->libObjPtr()), type); } }; using FieldClass = CommonFieldClass; using ConstFieldClass = CommonFieldClass; +namespace internal { + +struct FieldClassTypeDescr +{ + using Const = ConstFieldClass; + using NonConst = FieldClass; +}; + +template <> +struct TypeDescr : public FieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public FieldClassTypeDescr +{ +}; + +} /* namespace internal */ + template class CommonBitArrayFieldClass final : public CommonFieldClass { private: - using typename CommonFieldClass::_LibObjPtr; using typename CommonFieldClass::_ThisCommonFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonBitArrayFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isBitArray()); } template - CommonBitArrayFieldClass(const CommonBitArrayFieldClass& fc) noexcept : + CommonBitArrayFieldClass(const CommonBitArrayFieldClass fc) noexcept : _ThisCommonFieldClass {fc} { } template - CommonBitArrayFieldClass& - operator=(const CommonBitArrayFieldClass& fc) noexcept + CommonBitArrayFieldClass + operator=(const CommonBitArrayFieldClass fc) noexcept { _ThisCommonFieldClass::operator=(fc); return *this; } + CommonBitArrayFieldClass asConst() const noexcept + { + return CommonBitArrayFieldClass {*this}; + } + std::uint64_t length() const noexcept { - return bt_field_class_bit_array_get_length(this->_libObjPtr()); + return bt_field_class_bit_array_get_length(this->libObjPtr()); } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; using BitArrayFieldClass = CommonBitArrayFieldClass; using ConstBitArrayFieldClass = CommonBitArrayFieldClass; +namespace internal { + +struct BitArrayFieldClassTypeDescr +{ + using Const = ConstBitArrayFieldClass; + using NonConst = BitArrayFieldClass; +}; + +template <> +struct TypeDescr : public BitArrayFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public BitArrayFieldClassTypeDescr +{ +}; + +} /* namespace internal */ + enum class DisplayBase { - BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY, - OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL, - DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL, - HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL, + Binary = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY, + Octal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL, + Decimal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL, + Hexadecimal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL, }; template @@ -492,61 +534,69 @@ private: using typename CommonFieldClass::_ThisCommonFieldClass; protected: - using typename CommonFieldClass::_LibObjPtr; using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonIntegerFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isInteger()); } template - CommonIntegerFieldClass(const CommonIntegerFieldClass& fc) noexcept : + CommonIntegerFieldClass(const CommonIntegerFieldClass fc) noexcept : _ThisCommonFieldClass {fc} { } template - _ThisCommonIntegerFieldClass& - operator=(const CommonIntegerFieldClass& fc) noexcept + CommonIntegerFieldClass operator=(const CommonIntegerFieldClass fc) noexcept { _ThisCommonFieldClass::operator=(fc); return *this; } - void fieldValueRange(const std::uint64_t n) noexcept + CommonIntegerFieldClass asConst() const noexcept + { + return CommonIntegerFieldClass {*this}; + } + + CommonIntegerFieldClass fieldValueRange(const std::uint64_t n) const noexcept { - static_assert(!std::is_const::value, "`LibObjT` must NOT be `const`."); + static_assert(!std::is_const::value, + "Not available with `bt2::ConstIntegerFieldClass`."); - bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n); + bt_field_class_integer_set_field_value_range(this->libObjPtr(), n); + return *this; } std::uint64_t fieldValueRange() const noexcept { - return bt_field_class_integer_get_field_value_range(this->_libObjPtr()); + return bt_field_class_integer_get_field_value_range(this->libObjPtr()); } - void preferredDisplayBase(const DisplayBase base) noexcept + CommonIntegerFieldClass preferredDisplayBase(const DisplayBase base) const noexcept { - static_assert(!std::is_const::value, "`LibObjT` must NOT be `const`."); + static_assert(!std::is_const::value, + "Not available with `bt2::ConstIntegerFieldClass`."); bt_field_class_integer_set_preferred_display_base( - this->_libObjPtr(), static_cast(base)); + this->libObjPtr(), static_cast(base)); + return *this; } DisplayBase preferredDisplayBase() const noexcept { return static_cast( - bt_field_class_integer_get_preferred_display_base(this->_libObjPtr())); + bt_field_class_integer_get_preferred_display_base(this->libObjPtr())); } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; @@ -555,6 +605,22 @@ using ConstIntegerFieldClass = CommonIntegerFieldClass; namespace internal { +struct IntegerFieldClassTypeDescr +{ + using Const = ConstIntegerFieldClass; + using NonConst = IntegerFieldClass; +}; + +template <> +struct TypeDescr : public IntegerFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public IntegerFieldClassTypeDescr +{ +}; + template struct ConstEnumerationFieldClassMappingSpec; @@ -598,45 +664,44 @@ struct ConstEnumerationFieldClassMappingSpec -class ConstEnumerationFieldClassMapping final : public internal::BorrowedObj +class ConstEnumerationFieldClassMapping final : public BorrowedObject { private: - using typename internal::BorrowedObj::_ThisBorrowedObj; - using typename internal::BorrowedObj::_LibObjPtr; - using _ThisConstEnumerationFieldClassMapping = ConstEnumerationFieldClassMapping; + using typename BorrowedObject::_ThisBorrowedObject; public: + using typename BorrowedObject::LibObjPtr; + using RangeSet = typename std::conditional< std::is_same::value, ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type; - explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept : - _ThisBorrowedObj {libObjPtr} + explicit ConstEnumerationFieldClassMapping(const LibObjPtr libObjPtr) noexcept : + _ThisBorrowedObject {libObjPtr} { } - ConstEnumerationFieldClassMapping( - const _ThisConstEnumerationFieldClassMapping& mapping) noexcept : - _ThisBorrowedObj {mapping} + ConstEnumerationFieldClassMapping(const ConstEnumerationFieldClassMapping& mapping) noexcept : + _ThisBorrowedObject {mapping} { } - _ThisConstEnumerationFieldClassMapping& - operator=(const _ThisConstEnumerationFieldClassMapping& mapping) noexcept + ConstEnumerationFieldClassMapping + operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept { - _ThisBorrowedObj::operator=(mapping); + _ThisBorrowedObject::operator=(mapping); return *this; } RangeSet ranges() const noexcept { return RangeSet { - internal::ConstEnumerationFieldClassMappingSpec::ranges(this->_libObjPtr())}; + internal::ConstEnumerationFieldClassMappingSpec::ranges(this->libObjPtr())}; } - bpstd::string_view label() const noexcept + bt2c::CStringView label() const noexcept { - return internal::ConstEnumerationFieldClassMappingSpec::label(this->_libObjPtr()); + return internal::ConstEnumerationFieldClassMappingSpec::label(this->libObjPtr()); } }; @@ -666,6 +731,13 @@ struct CommonEnumerationFieldClassSpec { return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label); } + + static bt_field_class_enumeration_add_mapping_status + addMapping(bt_field_class * const libObjPtr, const char * const label, + const bt_integer_range_set_signed * const libRanges) noexcept + { + return bt_field_class_enumeration_signed_add_mapping(libObjPtr, label, libRanges); + } }; } /* namespace internal */ -template -class CommonEnumerationFieldClass final : public CommonIntegerFieldClass +template +class CommonBaseEnumerationFieldClass : public CommonIntegerFieldClass { private: - using typename CommonFieldClass::_LibObjPtr; using typename CommonIntegerFieldClass::_ThisCommonIntegerFieldClass; - using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass; + +protected: + using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass; public: - using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>; - using Mapping = MappingT; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>; - explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonBaseEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonIntegerFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isEnumeration()); } template - CommonEnumerationFieldClass( - const CommonEnumerationFieldClass& fc) noexcept : + CommonBaseEnumerationFieldClass(const CommonBaseEnumerationFieldClass fc) noexcept + : _ThisCommonIntegerFieldClass {fc} { } template - _ThisCommonEnumerationFieldClass& - operator=(const CommonEnumerationFieldClass& fc) noexcept + CommonBaseEnumerationFieldClass + operator=(const CommonBaseEnumerationFieldClass fc) noexcept { _ThisCommonIntegerFieldClass::operator=(fc); return *this; } - std::uint64_t size() const noexcept + CommonBaseEnumerationFieldClass asConst() const noexcept + { + return CommonBaseEnumerationFieldClass {*this}; + } + + std::uint64_t length() const noexcept + { + return bt_field_class_enumeration_get_mapping_count(this->libObjPtr()); + } + + Shared shared() const noexcept { - return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr()); + return Shared::createWithRef(*this); + } +}; + +template +class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass +{ +private: + using typename CommonBaseEnumerationFieldClass::_ThisCommonBaseEnumerationFieldClass; + +public: + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass; + using Iterator = BorrowedObjectIterator; + using Mapping = MappingT; + + explicit CommonEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept : + _ThisCommonBaseEnumerationFieldClass {libObjPtr} + { + BT_ASSERT_DBG(this->isEnumeration()); + } + + template + CommonEnumerationFieldClass( + const CommonEnumerationFieldClass fc) noexcept : + CommonEnumerationFieldClass {fc} + { + } + + template + CommonEnumerationFieldClass + operator=(const CommonEnumerationFieldClass fc) noexcept + { + CommonEnumerationFieldClass::operator=(fc); + return *this; } Mapping operator[](const std::uint64_t index) const noexcept { return Mapping {internal::CommonEnumerationFieldClassSpec::mappingByIndex( - this->_libObjPtr(), index)}; + this->libObjPtr(), index)}; + } + + OptionalBorrowedObject operator[](const bt2c::CStringView label) const noexcept + { + return internal::CommonEnumerationFieldClassSpec::mappingByLabel( + this->libObjPtr(), label); } - nonstd::optional operator[](const char * const label) const noexcept + CommonEnumerationFieldClass addMapping(const bt2c::CStringView label, + const typename Mapping::RangeSet ranges) const { - const auto libObjPtr = internal::CommonEnumerationFieldClassSpec::mappingByLabel( - this->_libObjPtr(), label); + const auto status = internal::CommonEnumerationFieldClassSpec::addMapping( + this->libObjPtr(), label, ranges.libObjPtr()); - if (libObjPtr) { - return Mapping {libObjPtr}; + if (status == BT_FIELD_CLASS_ENUMERATION_ADD_MAPPING_STATUS_MEMORY_ERROR) { + throw MemoryError {}; } - return nonstd::nullopt; + return *this; + } + + Iterator begin() const noexcept + { + return Iterator {*this, 0}; } - nonstd::optional operator[](const std::string& label) const noexcept + Iterator end() const noexcept { - return (*this)[label.data()]; + return Iterator {*this, this->length()}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; +using EnumerationFieldClass = CommonBaseEnumerationFieldClass; +using ConstEnumerationFieldClass = CommonBaseEnumerationFieldClass; + using UnsignedEnumerationFieldClass = CommonEnumerationFieldClass; @@ -768,6 +907,38 @@ using ConstSignedEnumerationFieldClass = namespace internal { +struct UnsignedEnumerationFieldClassTypeDescr +{ + using Const = ConstUnsignedEnumerationFieldClass; + using NonConst = UnsignedEnumerationFieldClass; +}; + +template <> +struct TypeDescr : public UnsignedEnumerationFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public UnsignedEnumerationFieldClassTypeDescr +{ +}; + +struct SignedEnumerationFieldClassTypeDescr +{ + using Const = ConstSignedEnumerationFieldClass; + using NonConst = SignedEnumerationFieldClass; +}; + +template <> +struct TypeDescr : public SignedEnumerationFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public SignedEnumerationFieldClassTypeDescr +{ +}; + template struct CommonStructureFieldClassMemberSpec; @@ -779,6 +950,11 @@ struct CommonStructureFieldClassMemberSpec fina { return bt_field_class_structure_member_borrow_field_class(libObjPtr); } + + static bt_value *userAttributes(bt_field_class_structure_member * const libObjPtr) noexcept + { + return bt_field_class_structure_member_borrow_user_attributes(libObjPtr); + } }; /* Functions specific to constant structure field class members */ @@ -790,56 +966,80 @@ struct CommonStructureFieldClassMemberSpec -class CommonStructureFieldClassMember final : public internal::BorrowedObj +class CommonStructureFieldClassMember final : public BorrowedObject { private: - using typename internal::BorrowedObj::_LibObjPtr; - using typename internal::BorrowedObj::_ThisBorrowedObj; - - using _FieldClass = - typename std::conditional::value, ConstFieldClass, FieldClass>::type; + using typename BorrowedObject::_ThisBorrowedObject; + using _FieldClass = internal::DepFc; public: - explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept : - _ThisBorrowedObj {libObjPtr} + using typename BorrowedObject::LibObjPtr; + using UserAttributes = internal::DepUserAttrs; + + explicit CommonStructureFieldClassMember(const LibObjPtr libObjPtr) noexcept : + _ThisBorrowedObject {libObjPtr} { } template - CommonStructureFieldClassMember( - const CommonStructureFieldClassMember& fc) noexcept : - _ThisBorrowedObj {fc} + CommonStructureFieldClassMember(const CommonStructureFieldClassMember fc) noexcept + : + _ThisBorrowedObject {fc} { } template - CommonStructureFieldClassMember& - operator=(const CommonStructureFieldClassMember& fc) noexcept + CommonStructureFieldClassMember + operator=(const CommonStructureFieldClassMember fc) noexcept { - _ThisBorrowedObj::operator=(fc); + _ThisBorrowedObject::operator=(fc); return *this; } - bpstd::string_view name() const noexcept + CommonStructureFieldClassMember asConst() const noexcept { - return bt_field_class_structure_member_get_name(this->_libObjPtr()); + return CommonStructureFieldClassMember {*this}; } - ConstFieldClass fieldClass() const noexcept + bt2c::CStringView name() const noexcept { - return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec< - const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())}; + return bt_field_class_structure_member_get_name(this->libObjPtr()); } - _FieldClass fieldClass() noexcept + _FieldClass fieldClass() const noexcept { return _FieldClass { - internal::CommonStructureFieldClassMemberSpec::fieldClass(this->_libObjPtr())}; + internal::CommonStructureFieldClassMemberSpec::fieldClass(this->libObjPtr())}; + } + + template + CommonStructureFieldClassMember + userAttributes(const CommonMapValue userAttrs) const noexcept + { + static_assert(!std::is_const::value, + "Not available with `bt2::ConstStructureFieldClassMember`."); + + bt_field_class_structure_member_set_user_attributes(this->libObjPtr(), + userAttrs.libObjPtr()); + return *this; + } + + UserAttributes userAttributes() const noexcept + { + return UserAttributes { + internal::CommonStructureFieldClassMemberSpec::userAttributes( + this->libObjPtr())}; } }; @@ -850,6 +1050,22 @@ using ConstStructureFieldClassMember = namespace internal { +struct StructureFieldClassMemberTypeDescr +{ + using Const = ConstStructureFieldClassMember; + using NonConst = StructureFieldClassMember; +}; + +template <> +struct TypeDescr : public StructureFieldClassMemberTypeDescr +{ +}; + +template <> +struct TypeDescr : public StructureFieldClassMemberTypeDescr +{ +}; + template struct CommonStructureFieldClassSpec; @@ -893,111 +1109,85 @@ template class CommonStructureFieldClass final : public CommonFieldClass { private: - using typename CommonFieldClass::_LibObjPtr; using typename CommonFieldClass::_ThisCommonFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; + using Iterator = BorrowedObjectIterator>; using Member = - typename std::conditional::value, ConstStructureFieldClassMember, - StructureFieldClassMember>::type; + internal::DepType; - explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonStructureFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isStructure()); } template - CommonStructureFieldClass(const CommonStructureFieldClass& fc) noexcept : + CommonStructureFieldClass(const CommonStructureFieldClass fc) noexcept : _ThisCommonFieldClass {fc} { } template - CommonStructureFieldClass& - operator=(const CommonStructureFieldClass& fc) noexcept + CommonStructureFieldClass operator=(const CommonStructureFieldClass fc) noexcept { _ThisCommonFieldClass::operator=(fc); return *this; } - void appendMember(const char * const name, const FieldClass& fc) + CommonStructureFieldClass asConst() const noexcept + { + return CommonStructureFieldClass {*this}; + } + + CommonStructureFieldClass appendMember(const bt2c::CStringView name, const FieldClass fc) const { - static_assert(!std::is_const::value, "`LibObjT` must NOT be `const`."); + static_assert(!std::is_const::value, + "Not available with `bt2::ConstStructureFieldClass`."); const auto status = - bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr()); + bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr()); if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) { - throw LibMemoryError {}; + throw MemoryError {}; } - } - - void appendMember(const std::string& name, const FieldClass& fc) - { - this->appendMember(name.data(), fc); - } - - std::uint64_t size() const noexcept - { - return bt_field_class_structure_get_member_count(this->_libObjPtr()); - } - ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept - { - return ConstStructureFieldClassMember { - internal::CommonStructureFieldClassSpec::memberByIndex( - this->_libObjPtr(), index)}; + return *this; } - Member operator[](const std::uint64_t index) noexcept + std::uint64_t length() const noexcept { - return Member {internal::CommonStructureFieldClassSpec::memberByIndex( - this->_libObjPtr(), index)}; + return bt_field_class_structure_get_member_count(this->libObjPtr()); } - nonstd::optional - operator[](const char * const name) const noexcept + Iterator begin() const noexcept { - const auto libObjPtr = - internal::CommonStructureFieldClassSpec::memberByName( - this->_libObjPtr(), name); - - if (libObjPtr) { - return ConstStructureFieldClassMember {libObjPtr}; - } - - return nonstd::nullopt; + return Iterator {*this, 0}; } - nonstd::optional - operator[](const std::string& name) const noexcept + Iterator end() const noexcept { - return (*this)[name.data()]; + return Iterator {*this, this->length()}; } - nonstd::optional operator[](const char * const name) noexcept + Member operator[](const std::uint64_t index) const noexcept { - const auto libObjPtr = internal::CommonStructureFieldClassSpec::memberByName( - this->_libObjPtr(), name); - - if (libObjPtr) { - return Member {libObjPtr}; - } - - return nonstd::nullopt; + return Member {internal::CommonStructureFieldClassSpec::memberByIndex( + this->libObjPtr(), index)}; } - nonstd::optional operator[](const std::string& name) noexcept + OptionalBorrowedObject operator[](const bt2c::CStringView name) const noexcept { - return (*this)[name.data()]; + return internal::CommonStructureFieldClassSpec::memberByName(this->libObjPtr(), + name); } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; @@ -1006,6 +1196,22 @@ using ConstStructureFieldClass = CommonStructureFieldClass namespace internal { +struct StructureFieldClassTypeDescr +{ + using Const = ConstStructureFieldClass; + using NonConst = StructureFieldClass; +}; + +template <> +struct TypeDescr : public StructureFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public StructureFieldClassTypeDescr +{ +}; + template struct CommonArrayFieldClassSpec; @@ -1036,114 +1242,154 @@ class CommonArrayFieldClass : public CommonFieldClass { private: using typename CommonFieldClass::_ThisCommonFieldClass; - - using _FieldClass = - typename std::conditional::value, ConstFieldClass, FieldClass>::type; + using _FieldClass = internal::DepFc; protected: - using typename CommonFieldClass::_LibObjPtr; using _ThisCommonArrayFieldClass = CommonArrayFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonArrayFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isArray()); } template - CommonArrayFieldClass(const CommonArrayFieldClass& fc) noexcept : + CommonArrayFieldClass(const CommonArrayFieldClass fc) noexcept : _ThisCommonFieldClass {fc} { } template - _ThisCommonArrayFieldClass& operator=(const CommonArrayFieldClass& fc) noexcept + CommonArrayFieldClass operator=(const CommonArrayFieldClass fc) noexcept { _ThisCommonFieldClass::operator=(fc); return *this; } - ConstFieldClass elementFieldClass() const noexcept + CommonArrayFieldClass asConst() const noexcept { - return ConstFieldClass { - internal::CommonArrayFieldClassSpec::elementFieldClass( - this->_libObjPtr())}; + return CommonArrayFieldClass {*this}; } - _FieldClass elementFieldClass() noexcept + _FieldClass elementFieldClass() const noexcept { return _FieldClass { - internal::CommonArrayFieldClassSpec::elementFieldClass(this->_libObjPtr())}; + internal::CommonArrayFieldClassSpec::elementFieldClass(this->libObjPtr())}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; using ArrayFieldClass = CommonArrayFieldClass; using ConstArrayFieldClass = CommonArrayFieldClass; +namespace internal { + +struct ArrayFieldClassTypeDescr +{ + using Const = ConstArrayFieldClass; + using NonConst = ArrayFieldClass; +}; + +template <> +struct TypeDescr : public ArrayFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public ArrayFieldClassTypeDescr +{ +}; + +} /* namespace internal */ + template class CommonStaticArrayFieldClass final : public CommonArrayFieldClass { private: using typename CommonArrayFieldClass::_ThisCommonArrayFieldClass; - using typename CommonFieldClass::_LibObjPtr; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonStaticArrayFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonArrayFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isStaticArray()); } template - CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass& fc) noexcept : + CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass fc) noexcept : _ThisCommonArrayFieldClass {fc} { } template - CommonStaticArrayFieldClass& - operator=(const CommonStaticArrayFieldClass& fc) noexcept + CommonStaticArrayFieldClass + operator=(const CommonStaticArrayFieldClass fc) noexcept { _ThisCommonArrayFieldClass::operator=(fc); return *this; } + CommonStaticArrayFieldClass asConst() const noexcept + { + return CommonStaticArrayFieldClass {*this}; + } + std::uint64_t length() const noexcept { - return bt_field_class_array_static_get_length(this->_libObjPtr()); + return bt_field_class_array_static_get_length(this->libObjPtr()); } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; using StaticArrayFieldClass = CommonStaticArrayFieldClass; using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass; +namespace internal { + +struct StaticArrayFieldClassTypeDescr +{ + using Const = ConstStaticArrayFieldClass; + using NonConst = StaticArrayFieldClass; +}; + +template <> +struct TypeDescr : public StaticArrayFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public StaticArrayFieldClassTypeDescr +{ +}; + +} /* namespace internal */ + template class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass { private: using typename CommonArrayFieldClass::_ThisCommonArrayFieldClass; - using typename CommonFieldClass::_LibObjPtr; public: - using Shared = - internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonDynamicArrayWithLengthFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonArrayFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isDynamicArrayWithLength()); @@ -1151,29 +1397,34 @@ public: template CommonDynamicArrayWithLengthFieldClass( - const CommonDynamicArrayWithLengthFieldClass& fc) noexcept : + const CommonDynamicArrayWithLengthFieldClass fc) noexcept : _ThisCommonArrayFieldClass {fc} { } template - CommonDynamicArrayWithLengthFieldClass& - operator=(const CommonDynamicArrayWithLengthFieldClass& fc) noexcept + CommonDynamicArrayWithLengthFieldClass + operator=(const CommonDynamicArrayWithLengthFieldClass fc) noexcept { _ThisCommonArrayFieldClass::operator=(fc); return *this; } + CommonDynamicArrayWithLengthFieldClass asConst() const noexcept + { + return CommonDynamicArrayWithLengthFieldClass {*this}; + } + ConstFieldPath lengthFieldPath() const noexcept { return ConstFieldPath { bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const( - this->_libObjPtr())}; + this->libObjPtr())}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; @@ -1184,6 +1435,24 @@ using ConstDynamicArrayWithLengthFieldClass = namespace internal { +struct DynamicArrayWithLengthFieldClassTypeDescr +{ + using Const = ConstDynamicArrayWithLengthFieldClass; + using NonConst = DynamicArrayWithLengthFieldClass; +}; + +template <> +struct TypeDescr : + public DynamicArrayWithLengthFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : + public DynamicArrayWithLengthFieldClassTypeDescr +{ +}; + template struct CommonOptionFieldClassSpec; @@ -1214,58 +1483,74 @@ class CommonOptionFieldClass : public CommonFieldClass { private: using typename CommonFieldClass::_ThisCommonFieldClass; - - using _FieldClass = - typename std::conditional::value, ConstFieldClass, FieldClass>::type; + using _FieldClass = internal::DepFc; protected: - using typename CommonFieldClass::_LibObjPtr; using _ThisCommonOptionFieldClass = CommonOptionFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonOptionFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isOption()); } template - CommonOptionFieldClass(const CommonOptionFieldClass& fc) noexcept : + CommonOptionFieldClass(const CommonOptionFieldClass fc) noexcept : _ThisCommonFieldClass {fc} { } template - _ThisCommonOptionFieldClass& operator=(const CommonOptionFieldClass& fc) noexcept + CommonOptionFieldClass operator=(const CommonOptionFieldClass fc) noexcept { _ThisCommonFieldClass::operator=(fc); return *this; } - ConstFieldClass fieldClass() const noexcept + CommonOptionFieldClass asConst() const noexcept { - return ConstFieldClass { - internal::CommonOptionFieldClassSpec::fieldClass( - this->_libObjPtr())}; + return CommonOptionFieldClass {*this}; } - _FieldClass fieldClass() noexcept + _FieldClass fieldClass() const noexcept { return _FieldClass { - internal::CommonOptionFieldClassSpec::fieldClass(this->_libObjPtr())}; + internal::CommonOptionFieldClassSpec::fieldClass(this->libObjPtr())}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; using OptionFieldClass = CommonOptionFieldClass; using ConstOptionFieldClass = CommonOptionFieldClass; +namespace internal { + +struct OptionFieldClassTypeDescr +{ + using Const = ConstOptionFieldClass; + using NonConst = OptionFieldClass; +}; + +template <> +struct TypeDescr : public OptionFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public OptionFieldClassTypeDescr +{ +}; + +} /* namespace internal */ + template class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass { @@ -1273,13 +1558,13 @@ private: using typename CommonOptionFieldClass::_ThisCommonOptionFieldClass; protected: - using typename CommonFieldClass::_LibObjPtr; using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonOptionWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonOptionFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isOptionWithSelector()); @@ -1287,49 +1572,72 @@ public: template CommonOptionWithSelectorFieldClass( - const CommonOptionWithSelectorFieldClass& fc) noexcept : + const CommonOptionWithSelectorFieldClass fc) noexcept : _ThisCommonOptionFieldClass {fc} { } template - _ThisCommonOptionWithSelectorFieldClass& - operator=(const CommonOptionWithSelectorFieldClass& fc) noexcept + CommonOptionWithSelectorFieldClass + operator=(const CommonOptionWithSelectorFieldClass fc) noexcept { _ThisCommonOptionFieldClass::operator=(fc); return *this; } + CommonOptionWithSelectorFieldClass asConst() const noexcept + { + return CommonOptionWithSelectorFieldClass {*this}; + } + ConstFieldPath selectorFieldPath() const noexcept { return ConstFieldPath { bt_field_class_option_with_selector_field_borrow_selector_field_path_const( - this->_libObjPtr())}; + this->libObjPtr())}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass; using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass; +namespace internal { + +struct OptionWithSelectorFieldClassTypeDescr +{ + using Const = ConstOptionWithSelectorFieldClass; + using NonConst = OptionWithSelectorFieldClass; +}; + +template <> +struct TypeDescr : public OptionWithSelectorFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : public OptionWithSelectorFieldClassTypeDescr +{ +}; + +} /* namespace internal */ + template class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass { private: - using typename CommonFieldClass::_LibObjPtr; - using typename CommonOptionWithSelectorFieldClass< LibObjT>::_ThisCommonOptionWithSelectorFieldClass; public: - using Shared = - internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; - explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonOptionWithBoolSelectorFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonOptionWithSelectorFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isOptionWithBoolSelector()); @@ -1337,28 +1645,33 @@ public: template CommonOptionWithBoolSelectorFieldClass( - const CommonOptionWithBoolSelectorFieldClass& fc) noexcept : + const CommonOptionWithBoolSelectorFieldClass fc) noexcept : _ThisCommonOptionWithSelectorFieldClass {fc} { } template - CommonOptionWithBoolSelectorFieldClass& - operator=(const CommonOptionWithBoolSelectorFieldClass& fc) noexcept + CommonOptionWithBoolSelectorFieldClass + operator=(const CommonOptionWithBoolSelectorFieldClass fc) noexcept { _ThisCommonOptionWithSelectorFieldClass::operator=(fc); return *this; } + CommonOptionWithBoolSelectorFieldClass asConst() const noexcept + { + return CommonOptionWithBoolSelectorFieldClass {*this}; + } + bool selectorIsReversed() const noexcept { return bt_field_class_option_with_selector_field_bool_selector_is_reversed( - this->_libObjPtr()); + this->libObjPtr()); } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; @@ -1369,6 +1682,24 @@ using ConstOptionWithBoolSelectorFieldClass = namespace internal { +struct OptionWithBoolSelectorFieldClassTypeDescr +{ + using Const = ConstOptionWithBoolSelectorFieldClass; + using NonConst = OptionWithBoolSelectorFieldClass; +}; + +template <> +struct TypeDescr : + public OptionWithBoolSelectorFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : + public OptionWithBoolSelectorFieldClassTypeDescr +{ +}; + template struct CommonOptionWithIntegerSelectorFieldClassSpec; @@ -1402,21 +1733,15 @@ template class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass { private: - using typename CommonFieldClass::_LibObjPtr; - using typename CommonOptionWithSelectorFieldClass< LibObjT>::_ThisCommonOptionWithSelectorFieldClass; - using _ThisCommonOptionWithIntegerSelectorFieldClass = - CommonOptionWithIntegerSelectorFieldClass; - public: - using Shared = - internal::SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>; - + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass; using RangeSet = RangeSetT; - explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonOptionWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonOptionWithSelectorFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isOptionWithIntegerSelector()); @@ -1424,14 +1749,14 @@ public: template CommonOptionWithIntegerSelectorFieldClass( - const CommonOptionWithIntegerSelectorFieldClass& fc) noexcept : + const CommonOptionWithIntegerSelectorFieldClass fc) noexcept : _ThisCommonOptionWithSelectorFieldClass {fc} { } template - _ThisCommonOptionWithIntegerSelectorFieldClass& - operator=(const CommonOptionWithIntegerSelectorFieldClass& fc) noexcept + CommonOptionWithIntegerSelectorFieldClass + operator=(const CommonOptionWithIntegerSelectorFieldClass fc) noexcept { _ThisCommonOptionWithSelectorFieldClass::operator=(fc); return *this; @@ -1440,12 +1765,12 @@ public: RangeSet ranges() const noexcept { return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec::ranges( - this->_libObjPtr())}; + this->libObjPtr())}; } Shared shared() const noexcept { - return Shared {*this}; + return Shared::createWithRef(*this); } }; @@ -1463,6 +1788,42 @@ using ConstOptionWithSignedIntegerSelectorFieldClass = namespace internal { +struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr +{ + using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass; + using NonConst = OptionWithUnsignedIntegerSelectorFieldClass; +}; + +template <> +struct TypeDescr : + public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : + public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr +{ +}; + +struct OptionWithSignedIntegerSelectorFieldClassTypeDescr +{ + using Const = ConstOptionWithSignedIntegerSelectorFieldClass; + using NonConst = OptionWithSignedIntegerSelectorFieldClass; +}; + +template <> +struct TypeDescr : + public OptionWithSignedIntegerSelectorFieldClassTypeDescr +{ +}; + +template <> +struct TypeDescr : + public OptionWithSignedIntegerSelectorFieldClassTypeDescr +{ +}; + template struct CommonVariantFieldClassOptionSpec; @@ -1474,6 +1835,11 @@ struct CommonVariantFieldClassOptionSpec final { return bt_field_class_variant_option_borrow_field_class(libObjPtr); } + + static bt_value *userAttributes(bt_field_class_variant_option * const libObjPtr) noexcept + { + return bt_field_class_variant_option_borrow_user_attributes(libObjPtr); + } }; /* Functions specific to constant variant field class options */ @@ -1485,55 +1851,77 @@ struct CommonVariantFieldClassOptionSpec fi { return bt_field_class_variant_option_borrow_field_class_const(libObjPtr); } + + static const bt_value * + userAttributes(const bt_field_class_variant_option * const libObjPtr) noexcept + { + return bt_field_class_variant_option_borrow_user_attributes_const(libObjPtr); + } }; } /* namespace internal */ template -class CommonVariantFieldClassOption : public internal::BorrowedObj +class CommonVariantFieldClassOption : public BorrowedObject { private: - using typename internal::BorrowedObj::_ThisBorrowedObj; - using typename internal::BorrowedObj::_LibObjPtr; - - using _FieldClass = - typename std::conditional::value, ConstFieldClass, FieldClass>::type; + using typename BorrowedObject::_ThisBorrowedObject; + using _FieldClass = internal::DepFc; public: - explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept : - _ThisBorrowedObj {libObjPtr} + using typename BorrowedObject::LibObjPtr; + using UserAttributes = internal::DepUserAttrs; + + explicit CommonVariantFieldClassOption(const LibObjPtr libObjPtr) noexcept : + _ThisBorrowedObject {libObjPtr} { } template - CommonVariantFieldClassOption(const CommonVariantFieldClassOption& fc) noexcept : - _ThisBorrowedObj {fc} + CommonVariantFieldClassOption(const CommonVariantFieldClassOption fc) noexcept : + _ThisBorrowedObject {fc} { } template - CommonVariantFieldClassOption& - operator=(const CommonVariantFieldClassOption& fc) noexcept + CommonVariantFieldClassOption + operator=(const CommonVariantFieldClassOption fc) noexcept { - _ThisBorrowedObj::operator=(fc); + _ThisBorrowedObject::operator=(fc); return *this; } - bpstd::string_view name() const noexcept + CommonVariantFieldClassOption asConst() const noexcept { - return bt_field_class_variant_option_get_name(this->_libObjPtr()); + return CommonVariantFieldClassOption {*this}; } - ConstFieldClass fieldClass() const noexcept + bt2c::CStringView name() const noexcept { - return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec< - const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())}; + return bt_field_class_variant_option_get_name(this->libObjPtr()); } - _FieldClass fieldClass() noexcept + _FieldClass fieldClass() const noexcept { return _FieldClass { - internal::CommonVariantFieldClassOptionSpec::fieldClass(this->_libObjPtr())}; + internal::CommonVariantFieldClassOptionSpec::fieldClass(this->libObjPtr())}; + } + + template + CommonVariantFieldClassOption + userAttributes(const CommonMapValue userAttrs) const noexcept + { + static_assert(!std::is_const::value, + "Not available with `bt2::ConstVariantFieldClassOption`."); + + bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr()); + return *this; + } + + UserAttributes userAttributes() const noexcept + { + return UserAttributes {internal::CommonVariantFieldClassOptionSpec::userAttributes( + this->libObjPtr())}; } }; @@ -1544,6 +1932,22 @@ using ConstVariantFieldClassOption = namespace internal { +struct VariantFieldClassOptionTypeDescr +{ + using Const = ConstVariantFieldClassOption; + using NonConst = VariantFieldClassOption; +}; + +template <> +struct TypeDescr : public VariantFieldClassOptionTypeDescr +{ +}; + +template <> +struct TypeDescr : public VariantFieldClassOptionTypeDescr +{ +}; + template struct ConstVariantWithIntegerSelectorFieldClassOptionSpec; @@ -1596,46 +2000,47 @@ struct ConstVariantWithIntegerSelectorFieldClassOptionSpec< } /* namespace internal */ template -class ConstVariantWithIntegerSelectorFieldClassOption : public internal::BorrowedObj +class ConstVariantWithIntegerSelectorFieldClassOption : public BorrowedObject { private: - using typename internal::BorrowedObj::_ThisBorrowedObj; - using typename internal::BorrowedObj::_LibObjPtr; + using typename BorrowedObject::_ThisBorrowedObject; using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec; public: + using typename BorrowedObject::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 : - _ThisBorrowedObj {libObjPtr} + explicit ConstVariantWithIntegerSelectorFieldClassOption(const LibObjPtr libObjPtr) noexcept : + _ThisBorrowedObject {libObjPtr} { } template ConstVariantWithIntegerSelectorFieldClassOption( - const ConstVariantWithIntegerSelectorFieldClassOption& fc) noexcept : - _ThisBorrowedObj {fc} + const ConstVariantWithIntegerSelectorFieldClassOption fc) noexcept : + _ThisBorrowedObject {fc} { } template - ConstVariantWithIntegerSelectorFieldClassOption& - operator=(const ConstVariantWithIntegerSelectorFieldClassOption& fc) noexcept + ConstVariantWithIntegerSelectorFieldClassOption + operator=(const ConstVariantWithIntegerSelectorFieldClassOption fc) noexcept { - _ThisBorrowedObj::operator=(fc); + _ThisBorrowedObject::operator=(fc); return *this; } ConstVariantFieldClassOption asBaseOption() const noexcept { - return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())}; + return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())}; } - bpstd::string_view name() const noexcept + bt2c::CStringView name() const noexcept { return this->asBaseOption().name(); } @@ -1647,7 +2052,7 @@ public: RangeSet ranges() const noexcept { - return RangeSet {_Spec::ranges(this->_libObjPtr())}; + return RangeSet {_Spec::ranges(this->libObjPtr())}; } }; @@ -1707,112 +2112,107 @@ private: using typename CommonFieldClass::_ThisCommonFieldClass; protected: - using typename CommonFieldClass::_LibObjPtr; using _ThisCommonVariantFieldClass = CommonVariantFieldClass; public: - using Shared = internal::SharedFieldClass, LibObjT>; + using typename CommonFieldClass::LibObjPtr; + using Shared = SharedFieldClass, LibObjT>; + using Iterator = BorrowedObjectIterator; using Option = - typename std::conditional::value, ConstVariantFieldClassOption, - VariantFieldClassOption>::type; + internal::DepType; - explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept : + explicit CommonVariantFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisCommonFieldClass {libObjPtr} { BT_ASSERT_DBG(this->isVariant()); } template - CommonVariantFieldClass(const CommonVariantFieldClass& fc) noexcept : + CommonVariantFieldClass(const CommonVariantFieldClass fc) noexcept : _ThisCommonFieldClass {fc} { } template - _ThisCommonVariantFieldClass& - operator=(const CommonVariantFieldClass& fc) noexcept + CommonVariantFieldClass operator=(const CommonVariantFieldClass fc) noexcept { _ThisCommonFieldClass::operator=(fc); return *this; } - std::uint64_t size() const noexcept - { - return bt_field_class_variant_get_option_count(this->_libObjPtr()); - } - - ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept + CommonVariantFieldClass asConst() const noexcept { - return ConstVariantFieldClassOption { - internal::CommonVariantFieldClassSpec::optionByIndex( - this->_libObjPtr(), index)}; + return CommonVariantFieldClass {*this}; } - Option operator[](const std::uint64_t index) noexcept + std::uint64_t length() const noexcept { - return Option {internal::CommonVariantFieldClassSpec::optionByIndex( - this->_libObjPtr(), index)}; + return bt_field_class_variant_get_option_count(this->libObjPtr()); } - nonstd::optional - operator[](const char * const name) const noexcept + Iterator begin() const noexcept { - const auto libObjPtr = - internal::CommonVariantFieldClassSpec::optionByName( - this->_libObjPtr(), name); - - if (libObjPtr) { - return ConstVariantFieldClassOption {libObjPtr}; - } - - return nonstd::nullopt; + return Iterator {*this, 0}; } - nonstd::optional - operator[](const std::string& name) const noexcept + Iterator end() const noexcept { - return (*this)[name.data()]; + return Iterator {*this, this->length()}; } - nonstd::optional