CHANGELOG.md

@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v6.0.0]
+
 ## Changes
 
 - Removed `HasReturnvaluesIF` class in favor of `returnvalue` namespace with `OK` and `FAILED`
@@ -16,6 +18,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
+- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
+  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
+  pointer.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
 - Add new `UnsignedByteField` class
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
 

src/fsfw/util/dataWrapper.h

@@ -9,7 +9,10 @@
 
 namespace util {
 
+using BufPair = std::pair<const uint8_t*, size_t>;
+
 struct RawData {
+  RawData() = default;
   const uint8_t* data = nullptr;
   size_t len = 0;
 };
@@ -17,14 +20,28 @@ struct RawData {
 enum DataTypes { NONE, RAW, SERIALIZABLE };
 
 union DataUnion {
-  RawData raw;
-  SerializeIF* serializable = nullptr;
+  RawData raw{};
+  SerializeIF* serializable;
 };
 
 struct DataWrapper {
+  
+  DataWrapper() = default;
+
+  DataWrapper(const uint8_t* data, size_t size): type(DataTypes::RAW) {
+    setRawData({data, size});
+  }
+
+  explicit DataWrapper(BufPair raw): type(DataTypes::RAW) {
+    setRawData(raw);
+  }
+
+  explicit DataWrapper(SerializeIF& serializable): type(DataTypes::SERIALIZABLE) {
+    setSerializable(serializable);
+  }
+
   DataTypes type = DataTypes::NONE;
   DataUnion dataUnion;
-  using BufPairT = std::pair<const uint8_t*, size_t>;
 
   [[nodiscard]] size_t getLength() const {
     if (type == DataTypes::RAW) {
@@ -42,7 +59,7 @@ struct DataWrapper {
     }
     return false;
   }
-  void setRawData(BufPairT bufPair) {
+  void setRawData(BufPair bufPair) {
     type = DataTypes::RAW;
     dataUnion.raw.data = bufPair.first;
     dataUnion.raw.len = bufPair.second;

unittests/util/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
   testUnsignedByteField.cpp
+  testDataWrapper.cpp
 )

unittests/util/testDataWrapper.cpp

@@ -0,0 +1,59 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/util/dataWrapper.h"
+#include "mocks/SimpleSerializable.h"
+
+TEST_CASE("Data Wrapper", "[util]") {
+  util::DataWrapper wrapper;
+  SECTION("State") {
+    REQUIRE(wrapper.isNull());
+    REQUIRE(wrapper.type == util::DataTypes::NONE);
+  }
+
+  SECTION("Set Raw Data") {
+    util::DataWrapper* instance = &wrapper;
+    bool deleteInst = false;
+    REQUIRE(wrapper.isNull());
+    std::array<uint8_t, 4> data = {1, 2, 3, 4};
+    SECTION("Setter") {
+      wrapper.setRawData({data.data(), data.size()});
+    }
+    SECTION("Direct Construction Pair") {
+      instance = new util::DataWrapper(util::BufPair(data.data(), data.size()));
+      deleteInst = true;
+    }
+    SECTION("Direct Construction Single Args") {
+      instance = new util::DataWrapper(data.data(), data.size());
+      deleteInst = true;
+    }
+    REQUIRE(not instance->isNull());
+    REQUIRE(instance->type == util::DataTypes::RAW);
+    REQUIRE(instance->dataUnion.raw.data == data.data());
+    REQUIRE(instance->dataUnion.raw.len == data.size());
+    if(deleteInst) {
+      delete instance;
+    }
+  }
+
+  SECTION("Simple Serializable") {
+    util::DataWrapper* instance = &wrapper;
+    bool deleteInst = false;
+    REQUIRE(instance->isNull());
+    SimpleSerializable serializable;
+    SECTION("Setter") {
+      wrapper.setSerializable(serializable);
+    }
+    SECTION("Direct Construction") {
+      instance = new util::DataWrapper(serializable);
+      deleteInst = true;
+    }
+
+    REQUIRE(not instance->isNull());
+    REQUIRE(instance->type == util::DataTypes::SERIALIZABLE);
+    REQUIRE(instance->dataUnion.serializable == &serializable);
+    if(deleteInst) {
+      delete instance;
+    }
+  }
+}

unittests/util/testUnsignedByteField.cpp

@@ -4,7 +4,7 @@
 
 #include "fsfw/util/UnsignedByteField.h"
 
-TEST_CASE("Unsigned Byte Field", "[unsigned-byte-field]") {
+TEST_CASE("Unsigned Byte Field", "[util]") {
   auto testByteField = UnsignedByteField<uint32_t>(10);
   auto u32ByteField = U32ByteField(10);
   auto u16ByteField = U16ByteField(5);