completed send helper tests

src/fsfw/pus/Service17Test.cpp

@@ -6,10 +6,7 @@
 #include "fsfw/tmtcservices/tmHelpers.h"
 
 Service17Test::Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId)
-    : PusServiceBase(objectId, apid, serviceId),
-      storeHelper(apid),
-      sendHelper(nullptr),
-      packetSubCounter(0) {}
+    : PusServiceBase(objectId, apid, serviceId), storeHelper(apid), packetSubCounter(0) {}
 
 Service17Test::~Service17Test() = default;
 

src/fsfw/pus/Service1TelecommandVerification.cpp

@@ -15,7 +15,6 @@ Service1TelecommandVerification::Service1TelecommandVerification(object_id_t obj
       apid(apid),
       serviceId(serviceId),
       targetDestination(targetDestination),
-      sendHelper(nullptr),
       storeHelper(apid) {
   tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

src/fsfw/pus/Service5EventReporting.cpp

@@ -11,7 +11,6 @@ Service5EventReporting::Service5EventReporting(object_id_t objectId, uint16_t ap
                                                uint8_t serviceId, size_t maxNumberReportsPerCycle,
                                                uint32_t messageQueueDepth)
     : PusServiceBase(objectId, apid, serviceId),
-      sendHelper(nullptr),
       storeHelper(apid),
       maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
   eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);

src/fsfw/storagemanager/LocalPool.cpp

@@ -194,8 +194,6 @@ void LocalPool::clearStore() {
     for (auto& size : sizeList) {
       size = STORAGE_FREE;
     }
-    //        std::memset(sizeList[index], 0xff,
-    //                numberOfElements[index] * sizeof(size_type));
   }
 }
 
@@ -338,3 +336,16 @@ void LocalPool::clearSubPool(max_subpools_t subpoolIndex) {
 }
 
 LocalPool::max_subpools_t LocalPool::getNumberOfSubPools() const { return NUMBER_OF_SUBPOOLS; }
+
+bool LocalPool::hasDataAtId(store_address_t storeId) const {
+  if (storeId.poolIndex >= NUMBER_OF_SUBPOOLS) {
+    return false;
+  }
+  if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
+    return false;
+  }
+  if (sizeLists[storeId.poolIndex][storeId.packetIndex] != STORAGE_FREE) {
+    return true;
+  }
+  return false;
+}

src/fsfw/storagemanager/LocalPool.h

@@ -132,6 +132,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
    * @return
    */
   max_subpools_t getNumberOfSubPools() const override;
+  bool hasDataAtId(store_address_t storeId) const override;
 
  protected:
   /**

src/fsfw/storagemanager/StorageManagerIF.h

@@ -163,6 +163,8 @@ class StorageManagerIF : public HasReturnvaluesIF {
   virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** p_data,
                                        bool ignoreFault = false) = 0;
 
+  [[nodiscard]] virtual bool hasDataAtId(store_address_t storeId) const = 0;
+
   /**
    * Clears the whole store.
    * Use with care!

src/fsfw/tmtcservices/CommandingServiceBase.cpp

@@ -21,7 +21,6 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId, uint16_t a
       service(service),
       timeoutSeconds(commandTimeoutSeconds),
       tmStoreHelper(apid),
-      tmSendHelper(nullptr),
       commandMap(numberOfParallelCommands) {
   commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
   requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);

src/fsfw/tmtcservices/PusServiceBase.cpp

@@ -131,8 +131,8 @@ void PusServiceBase::initializeTmHelpers(TmSendHelper& tmSendHelper, TmStoreHelp
 }
 
 void PusServiceBase::initializeTmSendHelper(TmSendHelper& tmSendHelper) {
-  tmSendHelper.setMsgQueue(requestQueue);
-  tmSendHelper.setMsgDestination(requestQueue->getDefaultDestination());
+  tmSendHelper.setMsgQueue(*requestQueue);
+  tmSendHelper.setDefaultDestination(requestQueue->getDefaultDestination());
   if (errReporter == nullptr) {
     errReporter =
         ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);

src/fsfw/tmtcservices/TmSendHelper.cpp

@@ -2,38 +2,50 @@
 
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 
-TmSendHelper::TmSendHelper(MessageQueueIF *queue, InternalErrorReporterIF *reporter,
+TmSendHelper::TmSendHelper() = default;
+
+TmSendHelper::TmSendHelper(MessageQueueIF &queue, InternalErrorReporterIF &reporter,
                            MessageQueueId_t tmtcMsgDest)
-    : tmtcMsgDest(tmtcMsgDest), queue(queue), errReporter(reporter) {}
+    : defaultDest(tmtcMsgDest), queue(&queue), errReporter(&reporter) {}
 
-TmSendHelper::TmSendHelper(MessageQueueIF *queue, InternalErrorReporterIF *reporter)
-    : queue(queue), errReporter(reporter) {}
+TmSendHelper::TmSendHelper(MessageQueueIF &queue, InternalErrorReporterIF &reporter)
+    : queue(&queue), errReporter(&reporter) {}
 
-TmSendHelper::TmSendHelper(InternalErrorReporterIF *reporter) : errReporter(reporter) {}
+TmSendHelper::TmSendHelper(InternalErrorReporterIF &reporter) : errReporter(&reporter) {}
 
 ReturnValue_t TmSendHelper::sendPacket(const store_address_t &storeId) {
   if (queue == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   TmTcMessage message(storeId);
-  ReturnValue_t result = queue->sendMessage(tmtcMsgDest, &message, ignoreFault);
+  ReturnValue_t result = queue->sendMessage(defaultDest, &message, ignoreFault);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    if (errReporter != nullptr) {
+    if (errReporter != nullptr and not ignoreFault) {
       errReporter->lostTm();
     }
     return result;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return result;
 }
 
-void TmSendHelper::setMsgDestination(MessageQueueId_t msgDest) { tmtcMsgDest = msgDest; }
+void TmSendHelper::setDefaultDestination(MessageQueueId_t msgDest) { defaultDest = msgDest; }
 
 void TmSendHelper::setInternalErrorReporter(InternalErrorReporterIF *reporter) {
   errReporter = reporter;
 }
-void TmSendHelper::setMsgQueue(MessageQueueIF *queue_) { queue = queue_; }
+void TmSendHelper::setMsgQueue(MessageQueueIF &queue_) { queue = &queue_; }
 
 ReturnValue_t TmSendHelper::sendPacket(MessageQueueId_t dest, const store_address_t &storeId) {
-  setMsgDestination(dest);
+  setDefaultDestination(dest);
   return sendPacket(storeId);
 }
+
+MessageQueueId_t TmSendHelper::getDefaultDestination() const { return defaultDest; }
+
+bool TmSendHelper::areFaultsIgnored() const { return ignoreFault; }
+void TmSendHelper::ignoreFaults() { ignoreFault = true; }
+void TmSendHelper::dontIgnoreFaults() { ignoreFault = false; }
+
+InternalErrorReporterIF *TmSendHelper::getInternalErrorReporter() const { return errReporter; }
+
+MessageQueueIF *TmSendHelper::getMsgQueue() const { return queue; }

src/fsfw/tmtcservices/TmSendHelper.h

@@ -9,22 +9,30 @@
 
 class TmSendHelper {
  public:
-  TmSendHelper(MessageQueueIF* queue, InternalErrorReporterIF* reporter,
+  TmSendHelper();
+  TmSendHelper(MessageQueueIF& queue, InternalErrorReporterIF& reporter,
                MessageQueueId_t tmtcMsgDest);
-  TmSendHelper(MessageQueueIF* queue, InternalErrorReporterIF* reporter);
-  explicit TmSendHelper(InternalErrorReporterIF* reporter);
+  TmSendHelper(MessageQueueIF& queue, InternalErrorReporterIF& reporter);
+  explicit TmSendHelper(InternalErrorReporterIF& reporter);
 
-  void setMsgQueue(MessageQueueIF* queue);
-  void setMsgDestination(MessageQueueId_t msgDest);
+  void setMsgQueue(MessageQueueIF& queue);
+  MessageQueueIF* getMsgQueue() const;
+
+  void setDefaultDestination(MessageQueueId_t msgDest);
+  [[nodiscard]] MessageQueueId_t getDefaultDestination() const;
+  [[nodiscard]] bool areFaultsIgnored() const;
+  void ignoreFaults();
+  void dontIgnoreFaults();
   void setInternalErrorReporter(InternalErrorReporterIF* reporter);
+  [[nodiscard]] InternalErrorReporterIF* getInternalErrorReporter() const;
   ReturnValue_t sendPacket(MessageQueueId_t dest, const store_address_t& storeId);
   ReturnValue_t sendPacket(const store_address_t& storeId);
 
  private:
-  MessageQueueId_t tmtcMsgDest = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t defaultDest = MessageQueueIF::NO_QUEUE;
   bool ignoreFault = false;
   MessageQueueIF* queue = nullptr;
-  InternalErrorReporterIF* errReporter;
+  InternalErrorReporterIF* errReporter = nullptr;
 };
 
 #endif  // FSFW_TMTCPACKET_TMSENDHELPER_H