projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
cpp-common: add `begin()` and `end()` to bt2::CommonEnumerationFieldClass
[babeltrace.git] / src / cpp-common / bt2 / field-class.hpp
diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index 642aff780ea2909920820fb0dfc744367ab37e27..c94e2cef5dbfe1b62abaa56626356b658cb9bd08 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -14,14 +14,16 @@
 #include "common/assert.h"
 #include "internal/borrowed-obj.hpp"
 #include "internal/shared-obj.hpp"
+#include "internal/utils.hpp"
 #include "cpp-common/optional.hpp"
 #include "cpp-common/string_view.hpp"
+#include "common-iter.hpp"
 #include "lib-error.hpp"
 #include "integer-range-set.hpp"
 #include "field-path.hpp"
+#include "value.hpp"
 
 namespace bt2 {
-
 namespace internal {
 
 struct FieldClassRefFuncs final
@@ -74,6 +76,9 @@ class CommonIntegerFieldClass;
 template <typename LibObjT>
 class ConstEnumerationFieldClassMapping;
 
+template <typename LibObjT>
+class CommonBaseEnumerationFieldClass;
+
 template <typename LibObjT, typename MappingT>
 class CommonEnumerationFieldClass;
 
@@ -107,6 +112,9 @@ class CommonOptionWithIntegerSelectorFieldClass;
 template <typename LibObjT>
 class CommonVariantWithoutSelectorFieldClass;
 
+template <typename LibObjT>
+class CommonVariantWithSelectorFieldClass;
+
 template <typename LibObjT>
 class ConstVariantWithIntegerSelectorFieldClassOption;
 
@@ -153,10 +161,10 @@ enum class FieldClassType
 template <typename LibObjT>
 class CommonFieldClass : public internal::BorrowedObj<LibObjT>
 {
-    /* Allow appendMember() to call `fc._libObjPtr()` */
+    /* Allow appendMember() to call `fc.libObjPtr()` */
     friend class CommonStructureFieldClass<bt_field_class>;
 
-    /* Allow appendOption() to call `fc._libObjPtr()` */
+    /* Allow appendOption() to call `fc.libObjPtr()` */
     friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
 
     friend class CommonVariantWithIntegerSelectorFieldClass<
@@ -169,11 +177,11 @@ class CommonFieldClass : public internal::BorrowedObj<LibObjT>
         ConstVariantWithIntegerSelectorFieldClassOption<
             const bt_field_class_variant_with_selector_field_integer_signed_option>>;
 
-    /* Allow *FieldClass() to call `fc._libObjPtr()` */
+    /* Allow *FieldClass() to call `fc.libObjPtr()` */
     friend class CommonEventClass<bt_event_class>;
     friend class CommonStreamClass<bt_stream_class>;
 
-    /* Allow create*FieldClass() to call `fc._libObjPtr()` */
+    /* Allow create*FieldClass() to call `fc.libObjPtr()` */
     friend class CommonTraceClass<bt_trace_class>;
 
 private:
@@ -199,7 +207,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
+    CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisBorrowedObj::operator=(fc);
         return *this;
@@ -207,7 +215,7 @@ public:
 
     FieldClassType type() const noexcept
     {
-        return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
+        return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
     }
 
     bool isBool() const noexcept
@@ -367,7 +375,7 @@ public:
 
     CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
     CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
-
+    CommonBaseEnumerationFieldClass<LibObjT> asEnumeration() const noexcept;
     CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
                                              const bt_field_class_enumeration_unsigned_mapping>>
     asUnsignedEnumeration() const noexcept;
@@ -392,6 +400,7 @@ public:
 
     CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
     CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
+    CommonVariantWithSelectorFieldClass<LibObjT> asVariantWithSelector() const noexcept;
 
     CommonVariantWithIntegerSelectorFieldClass<
         LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
@@ -408,19 +417,19 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
         return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
         return UserAttributes {
-            internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
+            internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -431,13 +440,33 @@ public:
 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<bt_field_class>;
 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct FieldClassTypeDescr
+{
+    using Const = ConstFieldClass;
+    using NonConst = FieldClass;
+};
+
+template <>
+struct TypeDescr<FieldClass> : public FieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstFieldClass> : public FieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
 {
@@ -470,7 +499,7 @@ public:
 
     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
@@ -482,6 +511,26 @@ public:
 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct BitArrayFieldClassTypeDescr
+{
+    using Const = ConstBitArrayFieldClass;
+    using NonConst = BitArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<BitArrayFieldClass> : public BitArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBitArrayFieldClass> : public BitArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 enum class DisplayBase
 {
     BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
@@ -516,8 +565,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonIntegerFieldClass&
-    operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
+    CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
@@ -527,12 +575,12 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
+        bt_field_class_integer_set_field_value_range(this->libObjPtr(), n);
     }
 
     std::uint64_t fieldValueRange() const noexcept
     {
-        return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
+        return bt_field_class_integer_get_field_value_range(this->libObjPtr());
     }
 
     void preferredDisplayBase(const DisplayBase base) noexcept
@@ -540,13 +588,13 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_field_class_integer_set_preferred_display_base(
-            this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
+            this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
     }
 
     DisplayBase preferredDisplayBase() const noexcept
     {
         return static_cast<DisplayBase>(
-            bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
+            bt_field_class_integer_get_preferred_display_base(this->libObjPtr()));
     }
 
     Shared shared() const noexcept
@@ -560,6 +608,26 @@ using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
 
 namespace internal {
 
+struct IntegerFieldClassTypeDescr
+{
+    using Const = ConstIntegerFieldClass;
+    using NonConst = IntegerFieldClass;
+};
+
+template <>
+struct TypeDescr<IntegerFieldClass> : public IntegerFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstIntegerFieldClass> : public IntegerFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
+namespace internal {
+
 template <typename LibObjT>
 struct ConstEnumerationFieldClassMappingSpec;
 
@@ -608,7 +676,6 @@ class ConstEnumerationFieldClassMapping final : public internal::BorrowedObj<Lib
 private:
     using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
     using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
-    using _ThisConstEnumerationFieldClassMapping = ConstEnumerationFieldClassMapping<LibObjT>;
 
 public:
     using RangeSet = typename std::conditional<
@@ -620,14 +687,13 @@ public:
     {
     }
 
-    ConstEnumerationFieldClassMapping(
-        const _ThisConstEnumerationFieldClassMapping& mapping) noexcept :
+    ConstEnumerationFieldClassMapping(const ConstEnumerationFieldClassMapping& mapping) noexcept :
         _ThisBorrowedObj {mapping}
     {
     }
 
-    _ThisConstEnumerationFieldClassMapping&
-    operator=(const _ThisConstEnumerationFieldClassMapping& mapping) noexcept
+    ConstEnumerationFieldClassMapping&
+    operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
     {
         _ThisBorrowedObj::operator=(mapping);
         return *this;
@@ -636,12 +702,12 @@ public:
     RangeSet ranges() const noexcept
     {
         return RangeSet {
-            internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
+            internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
     }
 
     bpstd::string_view label() const noexcept
     {
-        return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
+        return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
     }
 };
 
@@ -671,6 +737,13 @@ struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping
     {
         return bt_field_class_enumeration_unsigned_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_unsigned * const libRanges) noexcept
+    {
+        return bt_field_class_enumeration_unsigned_add_mapping(libObjPtr, label, libRanges);
+    }
 };
 
 /* Functions specific to signed enumeration field classes */
@@ -688,24 +761,77 @@ struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping>
     {
         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 <typename LibObjT>
+class CommonBaseEnumerationFieldClass : public CommonIntegerFieldClass<LibObjT>
+{
+private:
+    using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
+
+protected:
+    using typename CommonFieldClass<LibObjT>::_LibObjPtr;
+    using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass<LibObjT>;
+
+public:
+    using Shared = internal::SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
+
+    explicit CommonBaseEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
+        _ThisCommonIntegerFieldClass {libObjPtr}
+    {
+        BT_ASSERT_DBG(this->isEnumeration());
+    }
+
+    template <typename OtherLibObjT>
+    CommonBaseEnumerationFieldClass(
+        const CommonBaseEnumerationFieldClass<OtherLibObjT>& fc) noexcept :
+        _ThisCommonIntegerFieldClass {fc}
+    {
+    }
+
+    template <typename OtherLibObjT>
+    CommonBaseEnumerationFieldClass&
+    operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT>& fc) noexcept
+    {
+        _ThisCommonIntegerFieldClass::operator=(fc);
+        return *this;
+    }
+
+    std::uint64_t size() const noexcept
+    {
+        return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
+    }
+
+    Shared shared() const noexcept
+    {
+        return Shared {*this};
+    }
+};
+
 template <typename LibObjT, typename MappingT>
-class CommonEnumerationFieldClass final : public CommonIntegerFieldClass<LibObjT>
+class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass<LibObjT>
 {
 private:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
-    using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
+    using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
     using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
 
 public:
     using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
+    using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
     using Mapping = MappingT;
 
     explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
-        _ThisCommonIntegerFieldClass {libObjPtr}
+        _ThisCommonBaseEnumerationFieldClass {libObjPtr}
     {
         BT_ASSERT_DBG(this->isEnumeration());
     }
@@ -713,33 +839,28 @@ public:
     template <typename OtherLibObjT>
     CommonEnumerationFieldClass(
         const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
-        _ThisCommonIntegerFieldClass {fc}
+        _ThisCommonEnumerationFieldClass {fc}
     {
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonEnumerationFieldClass&
+    CommonEnumerationFieldClass&
     operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept
     {
-        _ThisCommonIntegerFieldClass::operator=(fc);
+        _ThisCommonEnumerationFieldClass::operator=(fc);
         return *this;
     }
 
-    std::uint64_t size() const noexcept
-    {
-        return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
-    }
-
     Mapping operator[](const std::uint64_t index) const noexcept
     {
         return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     nonstd::optional<Mapping> operator[](const char * const label) const noexcept
     {
         const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
-            this->_libObjPtr(), label);
+            this->libObjPtr(), label);
 
         if (libObjPtr) {
             return Mapping {libObjPtr};
@@ -753,12 +874,40 @@ public:
         return (*this)[label.data()];
     }
 
+    void addMapping(const char * const label, const typename Mapping::RangeSet ranges)
+    {
+        const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
+            this->libObjPtr(), label, ranges.libObjPtr());
+
+        if (status == BT_FIELD_CLASS_ENUMERATION_ADD_MAPPING_STATUS_MEMORY_ERROR) {
+            throw LibMemoryError {};
+        }
+    }
+
+    void addMapping(const std::string& label, const typename Mapping::RangeSet ranges)
+    {
+        this->addMapping(label.data(), ranges);
+    }
+
+    Iterator begin() const noexcept
+    {
+        return Iterator {*this, 0};
+    }
+
+    Iterator end() const noexcept
+    {
+        return Iterator {*this, this->size()};
+    }
+
     Shared shared() const noexcept
     {
         return Shared {*this};
     }
 };
 
+using EnumerationFieldClass = CommonBaseEnumerationFieldClass<bt_field_class>;
+using ConstEnumerationFieldClass = CommonBaseEnumerationFieldClass<const bt_field_class>;
+
 using UnsignedEnumerationFieldClass =
     CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
 
@@ -773,6 +922,38 @@ using ConstSignedEnumerationFieldClass =
 
 namespace internal {
 
+struct UnsignedEnumerationFieldClassTypeDescr
+{
+    using Const = ConstUnsignedEnumerationFieldClass;
+    using NonConst = UnsignedEnumerationFieldClass;
+};
+
+template <>
+struct TypeDescr<UnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
+{
+};
+
+struct SignedEnumerationFieldClassTypeDescr
+{
+    using Const = ConstSignedEnumerationFieldClass;
+    using NonConst = SignedEnumerationFieldClass;
+};
+
+template <>
+struct TypeDescr<SignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStructureFieldClassMemberSpec;
 
@@ -832,19 +1013,19 @@ public:
 
     bpstd::string_view name() const noexcept
     {
-        return bt_field_class_structure_member_get_name(this->_libObjPtr());
+        return bt_field_class_structure_member_get_name(this->libObjPtr());
     }
 
     ConstFieldClass fieldClass() const noexcept
     {
         return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
-            const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
+            const bt_field_class_structure_member>::fieldClass(this->libObjPtr())};
     }
 
     _FieldClass fieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+            internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 };
 
@@ -855,6 +1036,22 @@ using ConstStructureFieldClassMember =
 
 namespace internal {
 
+struct StructureFieldClassMemberTypeDescr
+{
+    using Const = ConstStructureFieldClassMember;
+    using NonConst = StructureFieldClassMember;
+};
+
+template <>
+struct TypeDescr<StructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStructureFieldClassSpec;
 
@@ -903,11 +1100,12 @@ private:
 
 public:
     using Shared = internal::SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
-
     using Member =
         typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
                                   StructureFieldClassMember>::type;
 
+    using Iterator = CommonIterator<CommonStructureFieldClass<LibObjT>, Member>;
+
     explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
     {
@@ -921,8 +1119,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonStructureFieldClass<LibObjT>&
-    operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
+    CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
@@ -933,7 +1130,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
+            bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
 
         if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -947,20 +1144,30 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_field_class_structure_get_member_count(this->_libObjPtr());
+        return bt_field_class_structure_get_member_count(this->libObjPtr());
+    }
+
+    Iterator begin() const noexcept
+    {
+        return Iterator {*this, 0};
+    }
+
+    Iterator end() const noexcept
+    {
+        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)};
+                this->libObjPtr(), index)};
     }
 
     Member operator[](const std::uint64_t index) noexcept
     {
         return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstStructureFieldClassMember>
@@ -968,7 +1175,7 @@ public:
     {
         const auto libObjPtr =
             internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
-                this->_libObjPtr(), name);
+                this->libObjPtr(), name);
 
         if (libObjPtr) {
             return ConstStructureFieldClassMember {libObjPtr};
@@ -985,8 +1192,8 @@ public:
 
     nonstd::optional<Member> operator[](const char * const name) noexcept
     {
-        const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
-            this->_libObjPtr(), name);
+        const auto libObjPtr =
+            internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return Member {libObjPtr};
@@ -1011,6 +1218,22 @@ using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>
 
 namespace internal {
 
+struct StructureFieldClassTypeDescr
+{
+    using Const = ConstStructureFieldClass;
+    using NonConst = StructureFieldClass;
+};
+
+template <>
+struct TypeDescr<StructureFieldClass> : public StructureFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureFieldClass> : public StructureFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonArrayFieldClassSpec;
 
@@ -1065,7 +1288,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
+    CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
@@ -1075,13 +1298,13 @@ public:
     {
         return ConstFieldClass {
             internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     _FieldClass elementFieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
+            internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1093,6 +1316,26 @@ public:
 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct ArrayFieldClassTypeDescr
+{
+    using Const = ConstArrayFieldClass;
+    using NonConst = ArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<ArrayFieldClass> : public ArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayFieldClass> : public ArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
 {
@@ -1116,7 +1359,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonStaticArrayFieldClass<LibObjT>&
+    CommonStaticArrayFieldClass&
     operator=(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonArrayFieldClass::operator=(fc);
@@ -1125,7 +1368,7 @@ public:
 
     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
@@ -1137,6 +1380,26 @@ public:
 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct StaticArrayFieldClassTypeDescr
+{
+    using Const = ConstStaticArrayFieldClass;
+    using NonConst = StaticArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<StaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
 {
@@ -1162,7 +1425,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonDynamicArrayWithLengthFieldClass<LibObjT>&
+    CommonDynamicArrayWithLengthFieldClass&
     operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonArrayFieldClass::operator=(fc);
@@ -1173,7 +1436,7 @@ public:
     {
         return ConstFieldPath {
             bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1189,6 +1452,24 @@ using ConstDynamicArrayWithLengthFieldClass =
 
 namespace internal {
 
+struct DynamicArrayWithLengthFieldClassTypeDescr
+{
+    using Const = ConstDynamicArrayWithLengthFieldClass;
+    using NonConst = DynamicArrayWithLengthFieldClass;
+};
+
+template <>
+struct TypeDescr<DynamicArrayWithLengthFieldClass> :
+    public DynamicArrayWithLengthFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
+    public DynamicArrayWithLengthFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonOptionFieldClassSpec;
 
@@ -1243,7 +1524,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
+    CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
@@ -1253,13 +1534,13 @@ public:
     {
         return ConstFieldClass {
             internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     _FieldClass fieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+            internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1271,6 +1552,26 @@ public:
 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct OptionFieldClassTypeDescr
+{
+    using Const = ConstOptionFieldClass;
+    using NonConst = OptionFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionFieldClass> : public OptionFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionFieldClass> : public OptionFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
 {
@@ -1298,7 +1599,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonOptionWithSelectorFieldClass&
+    CommonOptionWithSelectorFieldClass&
     operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonOptionFieldClass::operator=(fc);
@@ -1309,7 +1610,7 @@ public:
     {
         return ConstFieldPath {
             bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1321,6 +1622,26 @@ public:
 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct OptionWithSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithSelectorFieldClass;
+    using NonConst = OptionWithSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
 {
@@ -1348,7 +1669,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonOptionWithBoolSelectorFieldClass<LibObjT>&
+    CommonOptionWithBoolSelectorFieldClass&
     operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
@@ -1358,7 +1679,7 @@ public:
     bool selectorIsReversed() const noexcept
     {
         return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
-            this->_libObjPtr());
+            this->libObjPtr());
     }
 
     Shared shared() const noexcept
@@ -1374,6 +1695,24 @@ using ConstOptionWithBoolSelectorFieldClass =
 
 namespace internal {
 
+struct OptionWithBoolSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithBoolSelectorFieldClass;
+    using NonConst = OptionWithBoolSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithBoolSelectorFieldClass> :
+    public OptionWithBoolSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithBoolSelectorFieldClass> :
+    public OptionWithBoolSelectorFieldClassTypeDescr
+{
+};
+
 template <typename RangeSetT>
 struct CommonOptionWithIntegerSelectorFieldClassSpec;
 
@@ -1435,7 +1774,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonOptionWithIntegerSelectorFieldClass&
+    CommonOptionWithIntegerSelectorFieldClass&
     operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept
     {
         _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
@@ -1445,7 +1784,7 @@ public:
     RangeSet ranges() const noexcept
     {
         return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1468,6 +1807,42 @@ using ConstOptionWithSignedIntegerSelectorFieldClass =
 
 namespace internal {
 
+struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass;
+    using NonConst = OptionWithUnsignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithUnsignedIntegerSelectorFieldClass> :
+    public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithUnsignedIntegerSelectorFieldClass> :
+    public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+struct OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithSignedIntegerSelectorFieldClass;
+    using NonConst = OptionWithSignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithSignedIntegerSelectorFieldClass> :
+    public OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithSignedIntegerSelectorFieldClass> :
+    public OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonVariantFieldClassOptionSpec;
 
@@ -1517,7 +1892,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantFieldClassOption<LibObjT>&
+    CommonVariantFieldClassOption&
     operator=(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept
     {
         _ThisBorrowedObj::operator=(fc);
@@ -1526,19 +1901,19 @@ public:
 
     bpstd::string_view name() const noexcept
     {
-        return bt_field_class_variant_option_get_name(this->_libObjPtr());
+        return bt_field_class_variant_option_get_name(this->libObjPtr());
     }
 
     ConstFieldClass fieldClass() const noexcept
     {
         return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
-            const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
+            const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
     }
 
     _FieldClass fieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+            internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 };
 
@@ -1549,6 +1924,22 @@ using ConstVariantFieldClassOption =
 
 namespace internal {
 
+struct VariantFieldClassOptionTypeDescr
+{
+    using Const = ConstVariantFieldClassOption;
+    using NonConst = VariantFieldClassOption;
+};
+
+template <>
+struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
 
@@ -1628,7 +2019,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    ConstVariantWithIntegerSelectorFieldClassOption<LibObjT>&
+    ConstVariantWithIntegerSelectorFieldClassOption&
     operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
     {
         _ThisBorrowedObj::operator=(fc);
@@ -1637,7 +2028,7 @@ public:
 
     ConstVariantFieldClassOption asBaseOption() const noexcept
     {
-        return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
+        return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
     }
 
     bpstd::string_view name() const noexcept
@@ -1652,7 +2043,7 @@ public:
 
     RangeSet ranges() const noexcept
     {
-        return RangeSet {_Spec::ranges(this->_libObjPtr())};
+        return RangeSet {_Spec::ranges(this->libObjPtr())};
     }
 };
 
@@ -1722,6 +2113,8 @@ public:
         typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
                                   VariantFieldClassOption>::type;
 
+    using Iterator = CommonIterator<CommonVariantFieldClass<LibObjT>, Option>;
+
     explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
     {
@@ -1735,8 +2128,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonVariantFieldClass&
-    operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
+    CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
@@ -1744,20 +2136,30 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_field_class_variant_get_option_count(this->_libObjPtr());
+        return bt_field_class_variant_get_option_count(this->libObjPtr());
+    }
+
+    Iterator begin() const noexcept
+    {
+        return Iterator {*this, 0};
+    }
+
+    Iterator end() const noexcept
+    {
+        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)};
+                this->libObjPtr(), index)};
     }
 
     Option operator[](const std::uint64_t index) noexcept
     {
         return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstVariantFieldClassOption>
@@ -1765,7 +2167,7 @@ public:
     {
         const auto libObjPtr =
             internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
-                this->_libObjPtr(), name);
+                this->libObjPtr(), name);
 
         if (libObjPtr) {
             return ConstVariantFieldClassOption {libObjPtr};
@@ -1783,7 +2185,7 @@ public:
     nonstd::optional<Option> operator[](const char * const name) noexcept
     {
         const auto libObjPtr =
-            internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
+            internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return Option {libObjPtr};
@@ -1806,6 +2208,26 @@ public:
 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct VariantFieldClassTypeDescr
+{
+    using Const = ConstVariantFieldClass;
+    using NonConst = VariantFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
 {
@@ -1831,7 +2253,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantWithoutSelectorFieldClass<LibObjT>&
+    CommonVariantWithoutSelectorFieldClass&
     operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
     {
         _ThisCommonVariantFieldClass::operator=(fc);
@@ -1843,7 +2265,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status = bt_field_class_variant_without_selector_append_option(
-            this->_libObjPtr(), name, fc._libObjPtr());
+            this->libObjPtr(), name, fc.libObjPtr());
 
         if (status ==
             BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
@@ -1868,6 +2290,24 @@ using ConstVariantWithoutSelectorFieldClass =
 
 namespace internal {
 
+struct VariantWithoutSelectorFieldClassTypeDescr
+{
+    using Const = ConstVariantWithoutSelectorFieldClass;
+    using NonConst = VariantWithoutSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithoutSelectorFieldClass> :
+    public VariantWithoutSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
+    public VariantWithoutSelectorFieldClassTypeDescr
+{
+};
+
 template <typename OptionT>
 struct CommonVariantWithIntegerSelectorFieldClassSpec;
 
@@ -1933,13 +2373,61 @@ struct CommonVariantWithIntegerSelectorFieldClassSpec<
 
 } /* namespace internal */
 
-template <typename LibObjT, typename OptionT>
-class CommonVariantWithIntegerSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
+template <typename LibObjT>
+class CommonVariantWithSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
 {
 private:
     using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
+
+protected:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
+    using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
+
+public:
+    using Shared = internal::SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
 
+    explicit CommonVariantWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
+        _ThisCommonVariantFieldClass {libObjPtr}
+    {
+        BT_ASSERT_DBG(this->isVariantWithSelector());
+    }
+
+    template <typename OtherLibObjT>
+    CommonVariantWithSelectorFieldClass(
+        const CommonVariantWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
+        _ThisCommonVariantFieldClass {fc}
+    {
+    }
+
+    template <typename OtherLibObjT>
+    CommonVariantWithSelectorFieldClass&
+    operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
+    {
+        _ThisCommonVariantFieldClass::operator=(fc);
+        return *this;
+    }
+
+    ConstFieldPath selectorFieldPath() const noexcept
+    {
+        return ConstFieldPath {
+            bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
+                this->libObjPtr())};
+    }
+
+    Shared shared() const noexcept
+    {
+        return Shared {*this};
+    }
+};
+
+template <typename LibObjT, typename OptionT>
+class CommonVariantWithIntegerSelectorFieldClass :
+    public CommonVariantWithSelectorFieldClass<LibObjT>
+{
+private:
+    using typename CommonVariantWithSelectorFieldClass<
+        LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
+    using typename CommonFieldClass<LibObjT>::_LibObjPtr;
     using _ThisCommonVariantWithIntegerSelectorFieldClass =
         CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
 
@@ -1952,7 +2440,7 @@ public:
     using Option = OptionT;
 
     explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
-        _ThisCommonVariantFieldClass {libObjPtr}
+        _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
     {
         BT_ASSERT_DBG(this->isVariant());
     }
@@ -1960,33 +2448,26 @@ public:
     template <typename OtherLibObjT>
     CommonVariantWithIntegerSelectorFieldClass(
         const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
-        _ThisCommonVariantFieldClass {fc}
+        _ThisCommonVariantWithSelectorFieldClass {fc}
     {
     }
 
     template <typename OtherLibObjT>
-    _ThisCommonVariantWithIntegerSelectorFieldClass&
+    CommonVariantWithIntegerSelectorFieldClass&
     operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
     {
-        _ThisCommonVariantFieldClass::operator=(fc);
+        _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
         return *this;
     }
 
-    ConstFieldPath selectorFieldPath() const noexcept
-    {
-        return ConstFieldPath {
-            bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
-                this->_libObjPtr())};
-    }
-
     Option operator[](const std::uint64_t index) const noexcept
     {
-        return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
+        return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
     }
 
     nonstd::optional<Option> operator[](const char * const name) const noexcept
     {
-        const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
+        const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return Option {libObjPtr};
@@ -2006,7 +2487,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
+            _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
 
         if (status ==
             BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
@@ -2038,18 +2519,65 @@ using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelec
 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
     const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
 
+namespace internal {
+
+struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
+    using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
+    public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
+    public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
+    using NonConst = VariantWithSignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
+    public VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
+    public VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
 {
     BT_ASSERT_DBG(this->isBitArray());
-    return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
 {
     BT_ASSERT_DBG(this->isInteger());
-    return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
+}
+
+template <typename LibObjT>
+CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
+{
+    BT_ASSERT_DBG(this->isEnumeration());
+    return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2058,7 +2586,7 @@ CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isUnsignedEnumeration());
     return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2067,28 +2595,28 @@ CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isSignedEnumeration());
     return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
 {
     BT_ASSERT_DBG(this->isStructure());
-    return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
 {
     BT_ASSERT_DBG(this->isArray());
-    return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
 {
     BT_ASSERT_DBG(this->isStaticArray());
-    return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2096,14 +2624,14 @@ CommonDynamicArrayWithLengthFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
 {
     BT_ASSERT_DBG(this->isDynamicArrayWithLength());
-    return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
 {
     BT_ASSERT_DBG(this->isOption());
-    return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2111,7 +2639,7 @@ CommonOptionWithSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithSelector());
-    return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2119,7 +2647,7 @@ CommonOptionWithBoolSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithBoolSelector());
-    return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2128,7 +2656,7 @@ CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2137,14 +2665,14 @@ CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
 {
     BT_ASSERT_DBG(this->isVariant());
-    return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2152,7 +2680,15 @@ CommonVariantWithoutSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithoutSelector());
-    return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
+}
+
+template <typename LibObjT>
+CommonVariantWithSelectorFieldClass<LibObjT>
+CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
+{
+    BT_ASSERT_DBG(this->isVariantWithSelector());
+    return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2162,7 +2698,7 @@ CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
     return CommonVariantWithIntegerSelectorFieldClass<
-        LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
+        LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2172,7 +2708,7 @@ CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
     return CommonVariantWithIntegerSelectorFieldClass<
-        LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
+        LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
 }
 
 } /* namespace bt2 */
BabelTrace - Trace Format Babel Tower
This page took 0.045049 seconds and 4 git commands to generate.