field-class.hpp: Add CommonBaseEnumerationFieldClass

This is useful to call the `size()` method without knowing if the
enumeration field class is of the signed or unsigned type.

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I952fc54c015f8548489aab74e85cded23f9841f7
Reviewed-on: https://review.lttng.org/c/babeltrace/+/7510
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/10760
CI-Build: Philippe Proulx <eeppeliteloop@gmail.com>
Tested-by: jenkins <jenkins@lttng.org>
CI-Build: Simon Marchi <simon.marchi@efficios.com>

diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index 677f7fb466ab8209a947519a68ccfd894070ed69..f855002f89c1c084a1a03e25bc8e68cd6f3cabe9 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -76,6 +76,9 @@ class CommonIntegerFieldClass;
 template <typename LibObjT>
 class ConstEnumerationFieldClassMapping;
 
+template <typename LibObjT>
+class CommonBaseEnumerationFieldClass;
+
 template <typename LibObjT, typename MappingT>
 class CommonEnumerationFieldClass;
 
@@ -369,7 +372,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;
@@ -694,12 +697,57 @@ struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping>
 
 } /* 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>
+    _ThisCommonBaseEnumerationFieldClass&
+    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:
@@ -707,7 +755,7 @@ public:
     using Mapping = MappingT;
 
     explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
-        _ThisCommonIntegerFieldClass {libObjPtr}
+        _ThisCommonBaseEnumerationFieldClass {libObjPtr}
     {
         BT_ASSERT_DBG(this->isEnumeration());
     }
@@ -715,7 +763,7 @@ public:
     template <typename OtherLibObjT>
     CommonEnumerationFieldClass(
         const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
-        _ThisCommonIntegerFieldClass {fc}
+        _ThisCommonEnumerationFieldClass {fc}
     {
     }
 
@@ -723,15 +771,10 @@ public:
     _ThisCommonEnumerationFieldClass&
     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(
@@ -761,6 +804,9 @@ public:
     }
 };
 
+using EnumerationFieldClass = CommonBaseEnumerationFieldClass<bt_field_class>;
+using ConstEnumerationFieldClass = CommonBaseEnumerationFieldClass<const bt_field_class>;
+
 using UnsignedEnumerationFieldClass =
     CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
 
@@ -2077,6 +2123,13 @@ CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const no
     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>
 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept