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 8513c7952346f7a8e29b17541a0fcd1bbe39e8c6..c94e2cef5dbfe1b62abaa56626356b658cb9bd08 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -14,6 +14,7 @@
 #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"
@@ -23,7 +24,6 @@
 #include "value.hpp"
 
 namespace bt2 {
-
 namespace internal {
 
 struct FieldClassRefFuncs final
@@ -447,6 +447,26 @@ protected:
 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>
 {
@@ -491,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,
@@ -568,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;
 
@@ -677,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 */
@@ -694,6 +761,13 @@ 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 */
@@ -753,6 +827,7 @@ private:
 
 public:
     using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
+    using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
     using Mapping = MappingT;
 
     explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
@@ -799,6 +874,31 @@ 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};
@@ -822,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;
 
@@ -904,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;
 
@@ -1070,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;
 
@@ -1152,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>
 {
@@ -1196,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>
 {
@@ -1248,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;
 
@@ -1330,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>
 {
@@ -1380,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>
 {
@@ -1433,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;
 
@@ -1527,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;
 
@@ -1608,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;
 
@@ -1876,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>
 {
@@ -1938,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;
 
@@ -2149,6 +2519,46 @@ 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
 {