cpp-common/bt2: remove useless copy operations

[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 6682e5b52a07d9a239b358a2852594e881403e85..13ac7b4f7d26f097855926b12db55bd90b745d5c 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -16,8 +16,8 @@
 #include "cpp-common/optional.hpp"
 #include "cpp-common/string_view.hpp"
 
+#include "borrowed-object-iterator.hpp"
 #include "borrowed-object.hpp"
-#include "common-iterator.hpp"
 #include "exc.hpp"
 #include "field-path.hpp"
 #include "integer-range-set.hpp"
@@ -163,29 +163,6 @@ enum class FieldClassType
 template <typename LibObjT>
 class CommonFieldClass : public BorrowedObject<LibObjT>
 {
-    /* Allow appendMember() to call `fc.libObjPtr()` */
-    friend class CommonStructureFieldClass<bt_field_class>;
-
-    /* Allow appendOption() to call `fc.libObjPtr()` */
-    friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
-
-    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<bt_event_class>;
-    friend class CommonStreamClass<bt_stream_class>;
-
-    /* Allow create*FieldClass() to call `fc.libObjPtr()` */
-    friend class CommonTraceClass<bt_trace_class>;
-
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 
@@ -195,9 +172,7 @@ protected:
 
 public:
     using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
-
-    using UserAttributes =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+    using UserAttributes = internal::DepUserAttrs<LibObjT>;
 
     explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
     {
@@ -209,12 +184,17 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
+    CommonFieldClass operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
+    CommonFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonFieldClass<const bt_field_class> {*this};
+    }
+
     FieldClassType type() const noexcept
     {
         return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
@@ -423,7 +403,7 @@ public:
     template <typename LibValT>
     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstFieldClass`.");
 
         bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
@@ -492,13 +472,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonBitArrayFieldClass<LibObjT>&
+    CommonBitArrayFieldClass<LibObjT>
     operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonBitArrayFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonBitArrayFieldClass<const bt_field_class> {*this};
+    }
+
     std::uint64_t length() const noexcept
     {
         return bt_field_class_bit_array_get_length(this->libObjPtr());
@@ -567,15 +552,21 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
+    CommonIntegerFieldClass operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonIntegerFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonIntegerFieldClass<const bt_field_class> {*this};
+    }
+
     void fieldValueRange(const std::uint64_t n) const noexcept
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstIntegerFieldClass`.");
 
         bt_field_class_integer_set_field_value_range(this->libObjPtr(), n);
     }
@@ -587,7 +578,8 @@ public:
 
     void preferredDisplayBase(const DisplayBase base) const noexcept
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstIntegerFieldClass`.");
 
         bt_field_class_integer_set_preferred_display_base(
             this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
@@ -694,7 +686,7 @@ public:
     {
     }
 
-    ConstEnumerationFieldClassMapping&
+    ConstEnumerationFieldClassMapping
     operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
     {
         _ThisBorrowedObject::operator=(mapping);
@@ -801,14 +793,19 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonBaseEnumerationFieldClass&
+    CommonBaseEnumerationFieldClass
     operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonIntegerFieldClass::operator=(fc);
         return *this;
     }
 
-    std::uint64_t size() const noexcept
+    CommonBaseEnumerationFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonBaseEnumerationFieldClass<const bt_field_class> {*this};
+    }
+
+    std::uint64_t length() const noexcept
     {
         return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
     }
@@ -825,11 +822,10 @@ class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass
 private:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
     using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
-    using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
 
 public:
-    using Shared = SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
-    using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
+    using Shared = SharedFieldClass<CommonEnumerationFieldClass, LibObjT>;
+    using Iterator = BorrowedObjectIterator<CommonEnumerationFieldClass>;
     using Mapping = MappingT;
 
     explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
@@ -841,15 +837,15 @@ public:
     template <typename OtherLibObjT>
     CommonEnumerationFieldClass(
         const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
-        _ThisCommonEnumerationFieldClass {fc}
+        CommonEnumerationFieldClass {fc}
     {
     }
 
     template <typename OtherLibObjT>
-    CommonEnumerationFieldClass&
+    CommonEnumerationFieldClass
     operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
     {
-        _ThisCommonEnumerationFieldClass::operator=(fc);
+        CommonEnumerationFieldClass::operator=(fc);
         return *this;
     }
 
@@ -898,7 +894,7 @@ public:
 
     Iterator end() const noexcept
     {
-        return Iterator {*this, this->size()};
+        return Iterator {*this, this->length()};
     }
 
     Shared shared() const noexcept
@@ -999,13 +995,10 @@ class CommonStructureFieldClassMember final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
-
-    using _FieldClass =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+    using _FieldClass = internal::DepFc<LibObjT>;
 
 public:
-    using UserAttributes =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+    using UserAttributes = internal::DepUserAttrs<LibObjT>;
 
     explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
         _ThisBorrowedObject {libObjPtr}
@@ -1020,13 +1013,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonStructureFieldClassMember<LibObjT>&
+    CommonStructureFieldClassMember<LibObjT>
     operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
     {
         _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
+    CommonStructureFieldClassMember<const bt_field_class_structure_member> asConst() const noexcept
+    {
+        return CommonStructureFieldClassMember<const bt_field_class_structure_member> {*this};
+    }
+
     bpstd::string_view name() const noexcept
     {
         return bt_field_class_structure_member_get_name(this->libObjPtr());
@@ -1041,7 +1039,8 @@ public:
     template <typename LibValT>
     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstStructureFieldClassMember`.");
 
         bt_field_class_structure_member_set_user_attributes(this->libObjPtr(),
                                                             userAttrs.libObjPtr());
@@ -1126,11 +1125,10 @@ private:
 
 public:
     using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
-    using Member =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
-                                  StructureFieldClassMember>::type;
+    using Iterator = BorrowedObjectIterator<CommonStructureFieldClass<LibObjT>>;
 
-    using Iterator = CommonIterator<CommonStructureFieldClass<LibObjT>, Member>;
+    using Member =
+        internal::DepType<LibObjT, StructureFieldClassMember, ConstStructureFieldClassMember>;
 
     explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
@@ -1145,15 +1143,21 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
+    CommonStructureFieldClass operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonStructureFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonStructureFieldClass<const bt_field_class> {*this};
+    }
+
     void appendMember(const char * const name, const FieldClass fc) const
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstStructureFieldClass`.");
 
         const auto status =
             bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
@@ -1168,7 +1172,7 @@ public:
         this->appendMember(name.data(), fc);
     }
 
-    std::uint64_t size() const noexcept
+    std::uint64_t length() const noexcept
     {
         return bt_field_class_structure_get_member_count(this->libObjPtr());
     }
@@ -1180,7 +1184,7 @@ public:
 
     Iterator end() const noexcept
     {
-        return Iterator {*this, this->size()};
+        return Iterator {*this, this->length()};
     }
 
     Member operator[](const std::uint64_t index) const noexcept
@@ -1263,9 +1267,7 @@ class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
 {
 private:
     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
-
-    using _FieldClass =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+    using _FieldClass = internal::DepFc<LibObjT>;
 
 protected:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
@@ -1287,12 +1289,17 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
+    CommonArrayFieldClass operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonArrayFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonArrayFieldClass<const bt_field_class> {*this};
+    }
+
     _FieldClass elementFieldClass() const noexcept
     {
         return _FieldClass {
@@ -1351,13 +1358,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonStaticArrayFieldClass&
+    CommonStaticArrayFieldClass
     operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonArrayFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonStaticArrayFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonStaticArrayFieldClass<const bt_field_class> {*this};
+    }
+
     std::uint64_t length() const noexcept
     {
         return bt_field_class_array_static_get_length(this->libObjPtr());
@@ -1416,13 +1428,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonDynamicArrayWithLengthFieldClass&
+    CommonDynamicArrayWithLengthFieldClass
     operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonArrayFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonDynamicArrayWithLengthFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonDynamicArrayWithLengthFieldClass<const bt_field_class> {*this};
+    }
+
     ConstFieldPath lengthFieldPath() const noexcept
     {
         return ConstFieldPath {
@@ -1491,9 +1508,7 @@ class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
 {
 private:
     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
-
-    using _FieldClass =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+    using _FieldClass = internal::DepFc<LibObjT>;
 
 protected:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
@@ -1515,12 +1530,17 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
+    CommonOptionFieldClass operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonOptionFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonOptionFieldClass<const bt_field_class> {*this};
+    }
+
     _FieldClass fieldClass() const noexcept
     {
         return _FieldClass {
@@ -1583,13 +1603,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonOptionWithSelectorFieldClass&
+    CommonOptionWithSelectorFieldClass
     operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonOptionFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonOptionWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonOptionWithSelectorFieldClass<const bt_field_class> {*this};
+    }
+
     ConstFieldPath selectorFieldPath() const noexcept
     {
         return ConstFieldPath {
@@ -1652,13 +1677,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonOptionWithBoolSelectorFieldClass&
+    CommonOptionWithBoolSelectorFieldClass
     operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonOptionWithBoolSelectorFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonOptionWithBoolSelectorFieldClass<const bt_field_class> {*this};
+    }
+
     bool selectorIsReversed() const noexcept
     {
         return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
@@ -1734,12 +1764,8 @@ private:
     using typename CommonOptionWithSelectorFieldClass<
         LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
 
-    using _ThisCommonOptionWithIntegerSelectorFieldClass =
-        CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
-
 public:
-    using Shared = SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
-
+    using Shared = SharedFieldClass<CommonOptionWithIntegerSelectorFieldClass, LibObjT>;
     using RangeSet = RangeSetT;
 
     explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
@@ -1756,7 +1782,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonOptionWithIntegerSelectorFieldClass&
+    CommonOptionWithIntegerSelectorFieldClass
     operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
     {
         _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
@@ -1868,13 +1894,10 @@ class CommonVariantFieldClassOption : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-
-    using _FieldClass =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+    using _FieldClass = internal::DepFc<LibObjT>;
 
 public:
-    using UserAttributes =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+    using UserAttributes = internal::DepUserAttrs<LibObjT>;
 
     explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
         _ThisBorrowedObject {libObjPtr}
@@ -1888,13 +1911,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantFieldClassOption&
+    CommonVariantFieldClassOption
     operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
     {
         _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
+    CommonVariantFieldClassOption<const bt_field_class_variant_option> asConst() const noexcept
+    {
+        return CommonVariantFieldClassOption<const bt_field_class_variant_option> {*this};
+    }
+
     nonstd::optional<bpstd::string_view> name() const noexcept
     {
         const auto name = bt_field_class_variant_option_get_name(this->libObjPtr());
@@ -1915,7 +1943,8 @@ public:
     template <typename LibValT>
     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstVariantFieldClassOption`.");
 
         bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
@@ -2029,7 +2058,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    ConstVariantWithIntegerSelectorFieldClassOption&
+    ConstVariantWithIntegerSelectorFieldClassOption
     operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
     {
         _ThisBorrowedObject::operator=(fc);
@@ -2118,12 +2147,10 @@ protected:
 
 public:
     using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
+    using Iterator = BorrowedObjectIterator<CommonVariantFieldClass>;
 
     using Option =
-        typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
-                                  VariantFieldClassOption>::type;
-
-    using Iterator = CommonIterator<CommonVariantFieldClass, Option>;
+        internal::DepType<LibObjT, VariantFieldClassOption, ConstVariantFieldClassOption>;
 
     explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
@@ -2138,13 +2165,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
+    CommonVariantFieldClass operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonFieldClass::operator=(fc);
         return *this;
     }
 
-    std::uint64_t size() const noexcept
+    CommonVariantFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonVariantFieldClass<const bt_field_class> {*this};
+    }
+
+    std::uint64_t length() const noexcept
     {
         return bt_field_class_variant_get_option_count(this->libObjPtr());
     }
@@ -2156,7 +2188,7 @@ public:
 
     Iterator end() const noexcept
     {
-        return Iterator {*this, this->size()};
+        return Iterator {*this, this->length()};
     }
 
     Option operator[](const std::uint64_t index) const noexcept
@@ -2235,16 +2267,22 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantWithoutSelectorFieldClass&
+    CommonVariantWithoutSelectorFieldClass
     operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonVariantFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonVariantWithoutSelectorFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonVariantWithoutSelectorFieldClass<const bt_field_class> {*this};
+    }
+
     void appendOption(const char * const name, const FieldClass fc) const
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstVariantWithoutSelectorFieldClass`.");
 
         const auto status = bt_field_class_variant_without_selector_append_option(
             this->libObjPtr(), name, fc.libObjPtr());
@@ -2382,13 +2420,18 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantWithSelectorFieldClass&
+    CommonVariantWithSelectorFieldClass
     operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
     {
         _ThisCommonVariantFieldClass::operator=(fc);
         return *this;
     }
 
+    CommonVariantWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonVariantWithSelectorFieldClass<const bt_field_class> {*this};
+    }
+
     ConstFieldPath selectorFieldPath() const noexcept
     {
         return ConstFieldPath {
@@ -2414,17 +2457,15 @@ private:
     using typename CommonVariantWithSelectorFieldClass<
         LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
-    using _ThisCommonVariantWithIntegerSelectorFieldClass =
-        CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
 
     using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
 
 public:
-    using Shared = SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
-
+    using Shared = SharedFieldClass<CommonVariantWithIntegerSelectorFieldClass, LibObjT>;
     using Option = OptionT;
+
     using Iterator =
-        CommonIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>, Option>;
+        BorrowedObjectIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>>;
 
     explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
@@ -2440,7 +2481,7 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonVariantWithIntegerSelectorFieldClass&
+    CommonVariantWithIntegerSelectorFieldClass
     operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
     {
         _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
@@ -2471,7 +2512,9 @@ public:
     void appendOption(const char * const name, const FieldClass fc,
                       const typename Option::RangeSet ranges) const
     {
-        static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+        static_assert(
+            !std::is_const<LibObjT>::value,
+            "Not available with `bt2::ConstVariantWithUnsignedIntegerSelectorFieldClass`.");
 
         const auto status =
             _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
@@ -2495,7 +2538,7 @@ public:
 
     Iterator end() const noexcept
     {
-        return Iterator {*this, this->size()};
+        return Iterator {*this, this->length()};
     }
 
     Shared shared() const noexcept