field-class.hpp: Add CommonVariantWithSelectorFieldClass

This is useful to call the `selectorFieldPath()` method without knowing
if the variant field class has a signed or unsigned selector.

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: Ib54bfa31d8f818430ec378c7c0e0c9258e20e450
Reviewed-on: https://review.lttng.org/c/babeltrace/+/7511
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/10761
CI-Build: Philippe Proulx <eeppeliteloop@gmail.com>
Tested-by: jenkins <jenkins@lttng.org>

diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index f855002f89c1c084a1a03e25bc8e68cd6f3cabe9..d308c070cbb2cf8c52df10fdedac2567dcf72a27 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -112,6 +112,9 @@ class CommonOptionWithIntegerSelectorFieldClass;
 template <typename LibObjT>
 class CommonVariantWithoutSelectorFieldClass;
 
+template <typename LibObjT>
+class CommonVariantWithSelectorFieldClass;
+
 template <typename LibObjT>
 class ConstVariantWithIntegerSelectorFieldClassOption;
 
@@ -397,6 +400,7 @@ public:
 
     CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
     CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
+    CommonVariantWithSelectorFieldClass<LibObjT> asVariantWithSelector() const noexcept;
 
     CommonVariantWithIntegerSelectorFieldClass<
         LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
@@ -2004,13 +2008,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>
+    _ThisCommonVariantWithSelectorFieldClass&
+    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>;
 
@@ -2023,7 +2075,7 @@ public:
     using Option = OptionT;
 
     explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
-        _ThisCommonVariantFieldClass {libObjPtr}
+        _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
     {
         BT_ASSERT_DBG(this->isVariant());
     }
@@ -2031,7 +2083,7 @@ public:
     template <typename OtherLibObjT>
     CommonVariantWithIntegerSelectorFieldClass(
         const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
-        _ThisCommonVariantFieldClass {fc}
+        _ThisCommonVariantWithSelectorFieldClass {fc}
     {
     }
 
@@ -2039,17 +2091,10 @@ public:
     _ThisCommonVariantWithIntegerSelectorFieldClass&
     operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
     {
-        _ThisCommonVariantFieldClass::operator=(fc);
+        _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
         return *this;
     }
 
-    ConstFieldPath selectorFieldPath() const noexcept
-    {
-        return ConstFieldPath {
-            bt_field_class_variant_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)};
@@ -2233,6 +2278,14 @@ CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
     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>
 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
                                            ConstVariantWithUnsignedIntegerSelectorFieldClassOption>