remove newline

CHANGELOG.md

@@ -18,10 +18,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
-- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
-  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
-  types of telemetry.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
 - 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.

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1257,40 +1257,30 @@ ReturnValue_t DeviceHandlerBase::letChildHandleMessage(CommandMessage* message)
   return returnvalue::FAILED;
 }
 
-void DeviceHandlerBase::handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId,
+void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t replyId,
                                        bool forceDirectTm) {
-  if (dataWrapper.isNull()) {
+  if (dataSet == nullptr) {
     return;
   }
 
-  auto iter = deviceReplyMap.find(replyId);
+  DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
   if (iter == deviceReplyMap.end()) {
     triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
     return;
   }
 
-  auto reportData = [&](MessageQueueId_t queueId) {
+  /* Regular replies to a command */
-    if (dataWrapper.type == util::DataTypes::SERIALIZABLE) {
-      return actionHelper.reportData(queueId, replyId, dataWrapper.dataUnion.serializable);
-    } else if (dataWrapper.type == util::DataTypes::RAW) {
-      return actionHelper.reportData(queueId, replyId, dataWrapper.dataUnion.raw.data,
-                                     dataWrapper.dataUnion.raw.len);
-    }
-    return returnvalue::FAILED;
-  };
-
-  // Regular replies to a command
   if (iter->second.command != deviceCommandMap.end()) {
     MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
 
-    // This may fail, but we'll ignore the fault.
     if (queueId != NO_COMMANDER) {
-      reportData(queueId);
+      /* This may fail, but we'll ignore the fault. */
+      actionHelper.reportData(queueId, replyId, dataSet);
     }
 
-    // This check should make sure we get any TM but don't get anything doubled.
+    /* This check should make sure we get any TM but don't get anything doubled. */
     if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
-      DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataWrapper);
+      DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
       actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
     }
 
@@ -1299,16 +1289,22 @@ void DeviceHandlerBase::handleDeviceTm(util::DataWrapper dataWrapper, DeviceComm
       // hiding of sender needed so the service will handle it as
       // unexpected Data, no matter what state (progress or completed)
       // it is in
-      reportData(defaultRawReceiver);
+      actionHelper.reportData(defaultRawReceiver, replyId, dataSet, true);
     }
   }
-  // Unrequested or aperiodic replies
+  /* Unrequested or aperiodic replies */
   else {
-    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataWrapper);
+    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
     if (wiretappingMode == TM) {
       actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
     }
     if (forceDirectTm and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+      //		    sid_t setSid = sid_t(this->getObjectId(), replyId);
+      //		    LocalPoolDataSetBase* dataset = getDataSetHandle(setSid);
+      //		    if(dataset != nullptr) {
+      //	            poolManager.generateHousekeepingPacket(setSid, dataset, true);
+      //		    }
+
       // hiding of sender needed so the service will handle it as
       // unexpected Data, no matter what state (progress or completed)
       // it is in

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -23,7 +23,6 @@
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -1053,8 +1052,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   bool isAwaitingReply();
 
-  void handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId,
+  void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId, bool forceDirectTm = false);
-                      bool forceDirectTm = false);
+  //	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
+  //	        bool forceDirectTm);
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                          uint32_t *msToReachTheMode);

src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp

@@ -3,10 +3,10 @@
 #include "fsfw/serialize/SerializeAdapter.h"
 
 DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
-                                                   util::DataWrapper data)
+                                                   SerializeIF* data)
-    : objectId(objectId), actionId(actionId), dataWrapper(data) {}
+    : objectId(objectId), actionId(actionId), data(data) {}
 
-DeviceTmReportingWrapper::~DeviceTmReportingWrapper() = default;
+DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {}
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                                   Endianness streamEndianness) const {
@@ -19,27 +19,22 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size
   if (result != returnvalue::OK) {
     return result;
   }
-  if (dataWrapper.isNull()) {
+  return data->serialize(buffer, size, maxSize, streamEndianness);
-    return returnvalue::FAILED;
-  }
-  if (dataWrapper.type == util::DataTypes::SERIALIZABLE) {
-    return dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize, streamEndianness);
-  } else if (dataWrapper.type == util::DataTypes::RAW) {
-    if (*size + dataWrapper.dataUnion.raw.len > maxSize) {
-      return SerializeIF::BUFFER_TOO_SHORT;
-    }
-    std::memcpy(*buffer, dataWrapper.dataUnion.raw.data, dataWrapper.dataUnion.raw.len);
-    *buffer += dataWrapper.dataUnion.raw.len;
-    *size += dataWrapper.dataUnion.raw.len;
-  }
-  return returnvalue::OK;
 }
 
 size_t DeviceTmReportingWrapper::getSerializedSize() const {
-  return sizeof(objectId) + sizeof(ActionId_t) + dataWrapper.getLength();
+  return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer, size_t* size,
                                                     Endianness streamEndianness) {
-  return returnvalue::FAILED;
+  ReturnValue_t result = SerializeAdapter::deSerialize(&objectId, buffer, size, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&actionId, buffer, size, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return data->deSerialize(buffer, size, streamEndianness);
 }

src/fsfw/devicehandlers/DeviceTmReportingWrapper.h

@@ -1,29 +1,27 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 #define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
-#include "fsfw/action/HasActionsIF.h"
+#include "../action/HasActionsIF.h"
-#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "../objectmanager/SystemObjectIF.h"
-#include "fsfw/serialize/SerializeIF.h"
+#include "../serialize/SerializeIF.h"
-#include "fsfw/util/dataWrapper.h"
 
 class DeviceTmReportingWrapper : public SerializeIF {
  public:
-  DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, util::DataWrapper data);
+  DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, SerializeIF* data);
-  ~DeviceTmReportingWrapper() override;
+  virtual ~DeviceTmReportingWrapper();
 
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                   Endianness streamEndianness) const override;
 
-  [[nodiscard]] size_t getSerializedSize() const override;
+  virtual size_t getSerializedSize() const override;
+
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    Endianness streamEndianness) override;
 
  private:
   object_id_t objectId;
   ActionId_t actionId;
-  util::DataWrapper dataWrapper;
+  SerializeIF* data;
-
-  // Deserialization forbidden
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            Endianness streamEndianness) override;
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */