cpp-common: Add Blob, StaticBlob, and DynamicBlob FC

This commit copies the implementation of the static and dynamic array
field class wrappers.

The FieldClassType enum size is specified to 64 bits to accommodate for
enumerator value larger than 32 bits. (e.g.
BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITHOUT_LENGTH_FIELD)

Here is the clang++ error
In file included from ../../../../src/cpp-common/bt2/trace-ir.hpp:19:
  ../../../../src/cpp-common/bt2/field-class.hpp:170:20: error: enumerator value evaluates to 2684354560, which cannot be narrowed to type 'int' [-Wc++11-narrowing]
      DynamicBlob = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB,
                    ^
  ../../../../src/cpp-common/bt2/field-class.hpp:171:41: error: enumerator value evaluates to 6979321856, which cannot be narrowed to type 'int' [-Wc++11-narrowing]
      DynamicBlobWithoutLengthField = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITHOUT_LENGTH_FIELD,
                                      ^
  ../../../../src/cpp-common/bt2/field-class.hpp:172:38: error: enumerator value evaluates to 11274289152, which cannot be narrowed to type 'int' [-Wc++11-narrowing]
      DynamicBlobWithLengthField = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITH_LENGTH_FIELD,
                                   ^

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I0a8f14e811e80ef71edbe1e20e2cfcfac1df80b3
Reviewed-on: https://review.lttng.org/c/babeltrace/+/7620
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/12703
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 29d4a384dee4fb2180909234dfcbc30e8405df3a..6ba39aa4046d41e957ed80be371cbed321d9bf21 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -98,6 +98,15 @@ class CommonStaticArrayFieldClass;
 template <typename LibObjT>
 class CommonDynamicArrayWithLengthFieldClass;
 
+template <typename LibObjT>
+class CommonBlobFieldClass;
+
+template <typename LibObjT>
+class CommonStaticBlobFieldClass;
+
+template <typename LibObjT>
+class CommonDynamicBlobWithLengthFieldClass;
+
 template <typename LibObjT>
 class CommonOptionFieldClass;
 
@@ -134,7 +143,7 @@ class CommonStreamClass;
 template <typename LibObjT>
 class CommonTraceClass;
 
-enum class FieldClassType
+enum class FieldClassType : std::uint64_t
 {
     Bool = BT_FIELD_CLASS_TYPE_BOOL,
     BitArray = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
@@ -159,6 +168,10 @@ enum class FieldClassType
         BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
     VariantWithSignedIntegerSelector =
         BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
+    StaticBlob = BT_FIELD_CLASS_TYPE_STATIC_BLOB,
+    DynamicBlob = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB,
+    DynamicBlobWithoutLengthField = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITHOUT_LENGTH_FIELD,
+    DynamicBlobWithLengthField = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITH_LENGTH_FIELD,
 };
 
 template <typename LibObjT>
@@ -356,6 +369,31 @@ public:
         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
     }
 
+    bool isBlob() const noexcept
+    {
+        return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BLOB);
+    }
+
+    bool isStaticBlob() const noexcept
+    {
+        return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_BLOB);
+    }
+
+    bool isDynamicBlob() const noexcept
+    {
+        return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB);
+    }
+
+    bool isDynamicBlobWithoutLength() const noexcept
+    {
+        return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITHOUT_LENGTH_FIELD);
+    }
+
+    bool isDynamicBlobWithLength() const noexcept
+    {
+        return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITH_LENGTH_FIELD);
+    }
+
     template <typename FieldClassT>
     FieldClassT as() const noexcept
     {
@@ -377,6 +415,9 @@ public:
     CommonArrayFieldClass<LibObjT> asArray() const noexcept;
     CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
     CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
+    CommonBlobFieldClass<LibObjT> asBlob() const noexcept;
+    CommonStaticBlobFieldClass<LibObjT> asStaticBlob() const noexcept;
+    CommonDynamicBlobWithLengthFieldClass<LibObjT> asDynamicBlobWithLength() const noexcept;
     CommonOptionFieldClass<LibObjT> asOption() const noexcept;
     CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
     CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
@@ -1464,6 +1505,233 @@ struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
 {
 };
 
+} /* namespace internal */
+
+template <typename LibObjT>
+class CommonBlobFieldClass : public CommonFieldClass<LibObjT>
+{
+private:
+    using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
+
+protected:
+    using _ThisCommonBlobFieldClass = CommonBlobFieldClass<LibObjT>;
+
+public:
+    using Shared = SharedFieldClass<CommonBlobFieldClass<LibObjT>, LibObjT>;
+    using typename CommonFieldClass<LibObjT>::LibObjPtr;
+
+    explicit CommonBlobFieldClass(const LibObjPtr libObjPtr) noexcept :
+        _ThisCommonFieldClass {libObjPtr}
+    {
+        BT_ASSERT_DBG(this->isBlob());
+    }
+
+    template <typename OtherLibObjT>
+    CommonBlobFieldClass(const CommonBlobFieldClass<OtherLibObjT> fc) noexcept :
+        _ThisCommonFieldClass {fc}
+    {
+    }
+
+    template <typename OtherLibObjT>
+    CommonBlobFieldClass operator=(const CommonBlobFieldClass<OtherLibObjT> fc) noexcept
+    {
+        _ThisCommonFieldClass::operator=(fc);
+        return *this;
+    }
+
+    CommonBlobFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonBlobFieldClass<const bt_field_class> {*this};
+    }
+
+    bt2c::CStringView mediaType() const noexcept
+    {
+        return bt_field_class_blob_get_media_type(this->libObjPtr());
+    }
+
+    CommonBlobFieldClass mediaType(const bt2c::CStringView mediaType) const
+    {
+        static_assert(!std::is_const<LibObjT>::value,
+                      "Not available with `bt2::ConstBlobFieldClass`.");
+
+        if (bt_field_class_blob_set_media_type(this->libObjPtr(), mediaType) ==
+            BT_FIELD_CLASS_BLOB_SET_MEDIA_TYPE_STATUS_MEMORY_ERROR) {
+            throw MemoryError {};
+        }
+
+        return *this;
+    }
+
+    Shared shared() const noexcept
+    {
+        return Shared::createWithRef(*this);
+    }
+};
+
+using BlobFieldClass = CommonBlobFieldClass<bt_field_class>;
+using ConstBlobFieldClass = CommonBlobFieldClass<const bt_field_class>;
+
+namespace internal {
+
+struct BlobFieldClassTypeDescr
+{
+    using Const = ConstBlobFieldClass;
+    using NonConst = BlobFieldClass;
+};
+
+template <>
+struct TypeDescr<BlobFieldClass> : public BlobFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBlobFieldClass> : public BlobFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
+template <typename LibObjT>
+class CommonStaticBlobFieldClass final : public CommonBlobFieldClass<LibObjT>
+{
+private:
+    using typename CommonBlobFieldClass<LibObjT>::_ThisCommonBlobFieldClass;
+
+public:
+    using Shared = SharedFieldClass<CommonStaticBlobFieldClass<LibObjT>, LibObjT>;
+    using typename CommonFieldClass<LibObjT>::LibObjPtr;
+
+    explicit CommonStaticBlobFieldClass(const LibObjPtr libObjPtr) noexcept :
+        _ThisCommonBlobFieldClass {libObjPtr}
+    {
+        BT_ASSERT_DBG(this->isStaticBlob());
+    }
+
+    template <typename OtherLibObjT>
+    CommonStaticBlobFieldClass(const CommonStaticBlobFieldClass<OtherLibObjT> fc) noexcept :
+        _ThisCommonBlobFieldClass {fc}
+    {
+    }
+
+    template <typename OtherLibObjT>
+    CommonStaticBlobFieldClass operator=(const CommonStaticBlobFieldClass<OtherLibObjT> fc) noexcept
+    {
+        _ThisCommonBlobFieldClass::operator=(fc);
+        return *this;
+    }
+
+    CommonStaticBlobFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonStaticBlobFieldClass<const bt_field_class> {*this};
+    }
+
+    std::uint64_t length() const noexcept
+    {
+        return bt_field_class_blob_static_get_length(this->libObjPtr());
+    }
+
+    Shared shared() const noexcept
+    {
+        return Shared::createWithRef(*this);
+    }
+};
+
+using StaticBlobFieldClass = CommonStaticBlobFieldClass<bt_field_class>;
+using ConstStaticBlobFieldClass = CommonStaticBlobFieldClass<const bt_field_class>;
+
+namespace internal {
+
+struct StaticBlobFieldClassTypeDescr
+{
+    using Const = ConstStaticBlobFieldClass;
+    using NonConst = StaticBlobFieldClass;
+};
+
+template <>
+struct TypeDescr<StaticBlobFieldClass> : public StaticBlobFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStaticBlobFieldClass> : public StaticBlobFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
+template <typename LibObjT>
+class CommonDynamicBlobWithLengthFieldClass final : public CommonBlobFieldClass<LibObjT>
+{
+private:
+    using typename CommonBlobFieldClass<LibObjT>::_ThisCommonBlobFieldClass;
+
+public:
+    using Shared = SharedFieldClass<CommonDynamicBlobWithLengthFieldClass<LibObjT>, LibObjT>;
+    using typename CommonFieldClass<LibObjT>::LibObjPtr;
+
+    explicit CommonDynamicBlobWithLengthFieldClass(const LibObjPtr libObjPtr) noexcept :
+        _ThisCommonBlobFieldClass {libObjPtr}
+    {
+        BT_ASSERT_DBG(this->isDynamicBlobWithLength());
+    }
+
+    template <typename OtherLibObjT>
+    CommonDynamicBlobWithLengthFieldClass(
+        const CommonDynamicBlobWithLengthFieldClass<OtherLibObjT> fc) noexcept :
+        _ThisCommonBlobFieldClass {fc}
+    {
+    }
+
+    template <typename OtherLibObjT>
+    CommonDynamicBlobWithLengthFieldClass
+    operator=(const CommonDynamicBlobWithLengthFieldClass<OtherLibObjT> fc) noexcept
+    {
+        _ThisCommonBlobFieldClass::operator=(fc);
+        return *this;
+    }
+
+    CommonDynamicBlobWithLengthFieldClass<const bt_field_class> asConst() const noexcept
+    {
+        return CommonDynamicBlobWithLengthFieldClass<const bt_field_class> {*this};
+    }
+
+    ConstFieldLocation lengthFieldLocation() const noexcept
+    {
+        return ConstFieldLocation {
+            bt_field_class_blob_dynamic_with_length_field_borrow_length_field_location_const(
+                this->libObjPtr())};
+    }
+
+    Shared shared() const noexcept
+    {
+        return Shared::createWithRef(*this);
+    }
+};
+
+using DynamicBlobWithLengthFieldClass = CommonDynamicBlobWithLengthFieldClass<bt_field_class>;
+
+using ConstDynamicBlobWithLengthFieldClass =
+    CommonDynamicBlobWithLengthFieldClass<const bt_field_class>;
+
+namespace internal {
+
+struct DynamicBlobWithLengthFieldClassTypeDescr
+{
+    using Const = ConstDynamicBlobWithLengthFieldClass;
+    using NonConst = DynamicBlobWithLengthFieldClass;
+};
+
+template <>
+struct TypeDescr<DynamicBlobWithLengthFieldClass> : public DynamicBlobWithLengthFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDynamicBlobWithLengthFieldClass> :
+    public DynamicBlobWithLengthFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonOptionFieldClassSpec;
 
@@ -2655,6 +2923,28 @@ CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
     return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
 }
 
+template <typename LibObjT>
+CommonBlobFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBlob() const noexcept
+{
+    BT_ASSERT_DBG(this->isBlob());
+    return CommonBlobFieldClass<LibObjT> {this->libObjPtr()};
+}
+
+template <typename LibObjT>
+CommonStaticBlobFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticBlob() const noexcept
+{
+    BT_ASSERT_DBG(this->isStaticBlob());
+    return CommonStaticBlobFieldClass<LibObjT> {this->libObjPtr()};
+}
+
+template <typename LibObjT>
+CommonDynamicBlobWithLengthFieldClass<LibObjT>
+CommonFieldClass<LibObjT>::asDynamicBlobWithLength() const noexcept
+{
+    BT_ASSERT_DBG(this->isDynamicBlobWithLength());
+    return CommonDynamicBlobWithLengthFieldClass<LibObjT> {this->libObjPtr()};
+}
+
 template <typename LibObjT>
 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
 {

diff --git a/src/cpp-common/bt2/trace-ir.hpp b/src/cpp-common/bt2/trace-ir.hpp
index 5f0d87e116d0cd724e36f53923e5c6512c0094df..462291c7ba38f63c85779463c664e196cf26723c 100644 (file)
--- a/src/cpp-common/bt2/trace-ir.hpp
+++ b/src/cpp-common/bt2/trace-ir.hpp
@@ -1876,6 +1876,39 @@ public:
         return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
+    StaticBlobFieldClass::Shared createStaticBlobFieldClass(const std::uint64_t length) const
+    {
+        static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
+
+        const auto libObjPtr = bt_field_class_blob_static_create(this->libObjPtr(), length);
+
+        internal::validateCreatedObjPtr(libObjPtr);
+        return StaticBlobFieldClass::Shared::createWithoutRef(libObjPtr);
+    }
+
+    BlobFieldClass::Shared createDynamicBlobWithoutLengthFieldLocationFieldClass() const
+    {
+        static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
+
+        const auto libObjPtr =
+            bt_field_class_blob_dynamic_without_length_field_location_create(this->libObjPtr());
+
+        internal::validateCreatedObjPtr(libObjPtr);
+        return BlobFieldClass::Shared::createWithoutRef(libObjPtr);
+    }
+
+    DynamicBlobWithLengthFieldClass::Shared createDynamicBlobWithLengthFieldLocationFieldClass(
+        const ConstFieldLocation lengthFieldLocation) const
+    {
+        static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
+
+        const auto libObjPtr = bt_field_class_blob_dynamic_with_length_field_location_create(
+            this->libObjPtr(), lengthFieldLocation.libObjPtr());
+
+        internal::validateCreatedObjPtr(libObjPtr);
+        return DynamicBlobWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
+    }
+
     StructureFieldClass::Shared createStructureFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");