more clang-tidy improvements

.run/fsfw-tests_coverage.run.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="fsfw-tests_coverage" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
+  <configuration default="false" name="fsfw-tests_coverage" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-example-hosted" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-example-hosted" RUN_TARGET_NAME="fsfw-tests">
     <method v="2">
       <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
     </method>

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -17,8 +17,6 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom
   registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
 }
 
-MgmLIS3MDLHandler::~MgmLIS3MDLHandler() {}
-
 void MgmLIS3MDLHandler::doStartUp() {
   switch (internalState) {
     case (InternalState::STATE_NONE): {
@@ -90,7 +88,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
 
 uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
   command |= (1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
+  if (continuousCom) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;
@@ -98,7 +96,7 @@ uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
 
 uint8_t MgmLIS3MDLHandler::writeCommand(uint8_t command, bool continuousCom) {
   command &= ~(1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
+  if (continuousCom) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -28,7 +28,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
 
   MgmLIS3MDLHandler(uint32_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     uint32_t transitionDelay);
-  virtual ~MgmLIS3MDLHandler();
+  ~MgmLIS3MDLHandler() override = default;
 
   void enablePeriodicPrintouts(bool enable, uint8_t divider);
   /**
@@ -46,7 +46,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   void doShutDown() override;
   void doStartUp() override;
   void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
-  virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
+  uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
   ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
                                         size_t commandDataLen) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
@@ -60,9 +60,9 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * @param packet
    * @return
    */
-  virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void fillCommandAndReplyMap() override;
-  void modeChanged(void) override;
+  void modeChanged() override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
 
@@ -72,8 +72,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2;
 
   uint32_t transitionDelay;
-  // Single SPI command has 2 bytes, first for adress, second for content
-  size_t singleComandSize = 2;
   // Has the size for all adresses of the lis3mdl + the continous write bit
   uint8_t commandBuffer[MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1];
 
@@ -88,7 +86,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    */
   uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS];
 
-  uint8_t statusRegister = 0;
   bool goToNormalMode = false;
 
   enum class InternalState {
@@ -111,14 +108,14 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * @param single command to set the read-bit at
    * @param boolean to select a continuous read bit, default = false
    */
-  uint8_t readCommand(uint8_t command, bool continuousCom = false);
+  static uint8_t readCommand(uint8_t command, bool continuousCom = false);
 
   /**
    * Sets the write bit for the command
    * @param single command to set the write-bit at
    * @param boolean to select a continuous write bit, default = false
    */
-  uint8_t writeCommand(uint8_t command, bool continuousCom = false);
+  static uint8_t writeCommand(uint8_t command, bool continuousCom = false);
 
   /**
    * This Method gets the full scale for the measurement range

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -329,9 +329,9 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;
 
   // Now scale to physical value in microtesla
-  float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
-  float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
-  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
+  float fieldStrengthX = static_cast<float>(fieldStrengthRawX) * scaleFactorX;
+  float fieldStrengthY = static_cast<float>(fieldStrengthRawY) * scaleFactorY;
+  float fieldStrengthZ = static_cast<float>(fieldStrengthRawZ) * scaleFactorZ;
 
   if (periodicPrintout) {
     if (debugDivider.checkAndIncrement()) {

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -72,7 +72,6 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   RM3100::Rm3100PrimaryDataset primaryDataset;
 
   uint8_t commandBuffer[10];
-  uint8_t commandBufferLen = 0;
 
   uint8_t cmmRegValue = RM3100::CMM_VALUE;
   uint8_t tmrcRegValue = RM3100::TMRC_DEFAULT_VALUE;
@@ -100,4 +99,4 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
-#endif /* MISSION_DEVICEHANDLING_MGMRM3100HANDLER_H_ */
+#endif /* MISSION_DEVICES_MGMRM3100HANDLER_H_ */

src/fsfw/action/ActionHelper.cpp

@@ -6,7 +6,7 @@
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : owner(setOwner), queueToUse(useThisQueue) {}
 
-ActionHelper::~ActionHelper() {}
+ActionHelper::~ActionHelper() = default;
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
   if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
@@ -59,7 +59,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                     store_address_t dataAddress) {
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/ActionHelper.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../serialize/SerializeIF.h"
 #include "ActionMessage.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/serialize/SerializeIF.h"
 /**
  * @brief Action Helper is a helper class which handles action messages
  *

src/fsfw/action/ActionMessage.cpp

@@ -2,9 +2,9 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 
-ActionMessage::ActionMessage() {}
+ActionMessage::ActionMessage() = default;
 
-ActionMessage::~ActionMessage() {}
+ActionMessage::~ActionMessage() = default;
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
                                store_address_t parameters) {
@@ -64,9 +64,8 @@ void ActionMessage::clear(CommandMessage* message) {
   switch (message->getCommand()) {
     case EXECUTE_ACTION:
     case DATA_REPLY: {
-      StorageManagerIF* ipcStore =
-          ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-      if (ipcStore != NULL) {
+      auto* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+      if (ipcStore != nullptr) {
         ipcStore->deleteData(getStoreId(message));
       }
       break;

src/fsfw/action/CommandActionHelper.cpp

@@ -2,14 +2,14 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner)
-    : owner(setOwner), queueToUse(NULL), ipcStore(NULL), commandCount(0), lastTarget(0) {}
+    : owner(setOwner), queueToUse(nullptr), ipcStore(nullptr), commandCount(0), lastTarget(0) {}
 
-CommandActionHelper::~CommandActionHelper() {}
+CommandActionHelper::~CommandActionHelper() = default;
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                  SerializeIF *data) {
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
     return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
   }
   store_address_t storeId;
@@ -29,11 +29,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                  const uint8_t *data, uint32_t size) {
-  //    if (commandCount != 0) {
-  //        return CommandsFunctionsIF::ALREADY_COMMANDING;
-  //    }
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
     return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
   }
   store_address_t storeId;
@@ -59,12 +56,12 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI
 
 ReturnValue_t CommandActionHelper::initialize() {
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-  if (ipcStore == NULL) {
+  if (ipcStore == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   queueToUse = owner->getCommandQueuePtr();
-  if (queueToUse == NULL) {
+  if (queueToUse == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   return HasReturnvaluesIF::RETURN_OK;
@@ -104,7 +101,7 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 uint8_t CommandActionHelper::getCommandCount() const { return commandCount; }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-  const uint8_t *data = NULL;
+  const uint8_t *data = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/CommandActionHelper.h

@@ -14,14 +14,14 @@ class CommandActionHelper {
   friend class CommandsActionsIF;
 
  public:
-  CommandActionHelper(CommandsActionsIF* owner);
+  explicit CommandActionHelper(CommandsActionsIF* owner);
   virtual ~CommandActionHelper();
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
                               uint32_t size);
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
   ReturnValue_t initialize();
   ReturnValue_t handleReply(CommandMessage* reply);
-  uint8_t getCommandCount() const;
+  [[nodiscard]] uint8_t getCommandCount() const;
 
  private:
   CommandsActionsIF* owner;

src/fsfw/action/CommandsActionsIF.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
 #define FSFW_ACTION_COMMANDSACTIONSIF_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "CommandActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * Interface to separate commanding actions of other objects.
@@ -21,7 +21,7 @@ class CommandsActionsIF {
   static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
   static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
   static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-  virtual ~CommandsActionsIF() {}
+  virtual ~CommandsActionsIF() = default;
   virtual MessageQueueIF* getCommandQueuePtr() = 0;
 
  protected:

src/fsfw/action/HasActionsIF.h

@@ -1,11 +1,11 @@
 #ifndef FSFW_ACTION_HASACTIONSIF_H_
 #define FSFW_ACTION_HASACTIONSIF_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief
@@ -40,12 +40,12 @@ class HasActionsIF {
   static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
   static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
   static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-  virtual ~HasActionsIF() {}
+  virtual ~HasActionsIF() = default;
   /**
    * Function to get the MessageQueueId_t of the implementing object
    * @return MessageQueueId_t of the object
    */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
   /**
    * Execute or initialize the execution of a certain function.
    * The ActionHelpers will execute this function and behave differently

src/fsfw/action/SimpleActionHelper.cpp

@@ -3,7 +3,7 @@
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : ActionHelper(setOwner, useThisQueue), isExecuting(false) {}
 
-SimpleActionHelper::~SimpleActionHelper() {}
+SimpleActionHelper::~SimpleActionHelper() = default;
 
 void SimpleActionHelper::step(ReturnValue_t result) {
   // STEP_OFFESET is subtracted to compensate for adding offset in base
@@ -38,7 +38,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
     ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::IS_BUSY);
     queueToUse->sendMessage(commandedBy, &reply);
   }
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/SimpleActionHelper.h

@@ -11,15 +11,15 @@
 class SimpleActionHelper : public ActionHelper {
  public:
   SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-  virtual ~SimpleActionHelper();
+  ~SimpleActionHelper() override;
   void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
   void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
   ReturnValue_t reportData(SerializeIF* data);
 
  protected:
   void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-                        store_address_t dataAddress);
-  virtual void resetHelper();
+                        store_address_t dataAddress) override;
+  void resetHelper() override;
 
  private:
   bool isExecuting;
@@ -28,4 +28,4 @@ class SimpleActionHelper : public ActionHelper {
   uint8_t stepCount = 0;
 };
 
-#endif /* SIMPLEACTIONHELPER_H_ */
+#endif /* FSFW_ACTION_SIMPLEACTIONHELPER_H_ */

src/fsfw/cfdp/pdu/AckInfo.cpp

@@ -13,10 +13,12 @@ AckInfo::AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedC
   }
 }
 
+AckInfo::AckInfo() = default;
+
 cfdp::ConditionCode AckInfo::getAckedConditionCode() const { return ackedConditionCode; }
 
-void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
-  this->ackedConditionCode = ackedConditionCode;
+void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode_) {
+  ackedConditionCode = ackedConditionCode_;
   if (ackedDirective == cfdp::FileDirectives::FINISH) {
     this->directiveSubtypeCode = 0b0001;
   } else {
@@ -26,20 +28,18 @@ void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
 
 cfdp::FileDirectives AckInfo::getAckedDirective() const { return ackedDirective; }
 
-void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective) {
-  this->ackedDirective = ackedDirective;
+void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective_) {
+  ackedDirective = ackedDirective_;
 }
 
 uint8_t AckInfo::getDirectiveSubtypeCode() const { return directiveSubtypeCode; }
 
-void AckInfo::setDirectiveSubtypeCode(uint8_t directiveSubtypeCode) {
-  this->directiveSubtypeCode = directiveSubtypeCode;
+void AckInfo::setDirectiveSubtypeCode(uint8_t directiveSubtypeCode_) {
+  directiveSubtypeCode = directiveSubtypeCode_;
 }
 
 cfdp::AckTransactionStatus AckInfo::getTransactionStatus() const { return transactionStatus; }
 
-AckInfo::AckInfo() {}
-
-void AckInfo::setTransactionStatus(cfdp::AckTransactionStatus transactionStatus) {
-  this->transactionStatus = transactionStatus;
+void AckInfo::setTransactionStatus(cfdp::AckTransactionStatus transactionStatus_) {
+  transactionStatus = transactionStatus_;
 }

src/fsfw/cfdp/pdu/AckInfo.h

@@ -9,16 +9,16 @@ class AckInfo {
   AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedConditionCode,
           cfdp::AckTransactionStatus transactionStatus, uint8_t directiveSubtypeCode = 0);
 
-  cfdp::ConditionCode getAckedConditionCode() const;
-  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode);
+  [[nodiscard]] cfdp::ConditionCode getAckedConditionCode() const;
+  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode_);
 
-  cfdp::FileDirectives getAckedDirective() const;
+  [[nodiscard]] cfdp::FileDirectives getAckedDirective() const;
   void setAckedDirective(cfdp::FileDirectives ackedDirective);
 
-  uint8_t getDirectiveSubtypeCode() const;
+  [[nodiscard]] uint8_t getDirectiveSubtypeCode() const;
   void setDirectiveSubtypeCode(uint8_t directiveSubtypeCode);
 
-  cfdp::AckTransactionStatus getTransactionStatus() const;
+  [[nodiscard]] cfdp::AckTransactionStatus getTransactionStatus() const;
   void setTransactionStatus(cfdp::AckTransactionStatus transactionStatus);
 
  private:

src/fsfw/cfdp/pdu/AckPduDeserializer.h

@@ -13,7 +13,7 @@ class AckPduDeserializer : public FileDirectiveDeserializer {
    * @return
    *  - cfdp::INVALID_DIRECTIVE_FIELDS: Invalid fields
    */
-  ReturnValue_t parseData();
+  ReturnValue_t parseData() override;
 
  private:
   bool checkAndSetCodes(uint8_t rawAckedByte, uint8_t rawAckedConditionCode);

src/fsfw/cfdp/pdu/AckPduSerializer.h

@@ -18,7 +18,7 @@ class AckPduSerializer : public FileDirectiveSerializer {
    */
   AckPduSerializer(AckInfo& ackInfo, PduConfig& pduConf);
 
-  size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;

src/fsfw/controller/ControllerBase.cpp

@@ -26,7 +26,7 @@ ReturnValue_t ControllerBase::initialize() {
 
   MessageQueueId_t parentQueue = 0;
   if (parentId != objects::NO_OBJECT) {
-    SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
+    auto* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
     if (parent == nullptr) {
       return RETURN_FAILED;
     }
@@ -52,7 +52,7 @@ MessageQueueId_t ControllerBase::getCommandQueue() const { return commandQueue->
 
 void ControllerBase::handleQueue() {
   CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result;
   for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
        result = commandQueue->receiveMessage(&command)) {
     result = modeHelper.handleModeCommand(&command);
@@ -73,20 +73,20 @@ void ControllerBase::handleQueue() {
   }
 }
 
-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+void ControllerBase::startTransition(Mode_t mode_, Submode_t submode_) {
   changeHK(this->mode, this->submode, false);
   triggerEvent(CHANGING_MODE, mode, submode);
-  this->mode = mode;
-  this->submode = submode;
+  mode = mode_;
+  submode = submode_;
   modeHelper.modeChanged(mode, submode);
   modeChanged(mode, submode);
   announceMode(false);
   changeHK(this->mode, this->submode, true);
 }
 
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-  *mode = this->mode;
-  *submode = this->submode;
+void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) {
+  *mode_ = this->mode;
+  *submode_ = this->submode;
 }
 
 void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); }
@@ -99,7 +99,7 @@ ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
   return RETURN_OK;
 }
 
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) { return; }
+void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}
 
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
   switch (health) {
@@ -115,6 +115,6 @@ ReturnValue_t ControllerBase::setHealth(HealthState health) {
 HasHealthIF::HealthState ControllerBase::getHealth() { return healthHelper.getHealth(); }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }
 
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {}
+void ControllerBase::changeHK(Mode_t mode_, Submode_t submode_, bool enable) {}
 
 ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return HasReturnvaluesIF::RETURN_OK; }

src/fsfw/controller/ControllerBase.h

@@ -24,21 +24,21 @@ class ControllerBase : public HasModesIF,
   static const Mode_t MODE_NORMAL = 2;
 
   ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ControllerBase();
+  ~ControllerBase() override;
 
   /** SystemObject override */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
   /** HasHealthIF overrides */
-  virtual ReturnValue_t setHealth(HealthState health) override;
-  virtual HasHealthIF::HealthState getHealth() override;
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;
 
   /** ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual void setTaskIF(PeriodicTaskIF *task) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  void setTaskIF(PeriodicTaskIF *task) override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   /**
@@ -54,7 +54,7 @@ class ControllerBase : public HasModesIF,
    */
   virtual void performControlOperation() = 0;
 
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t *msToReachTheMode) override = 0;
 
   const object_id_t parentId;
@@ -80,10 +80,10 @@ class ControllerBase : public HasModesIF,
 
   /** Mode helpers */
   virtual void modeChanged(Mode_t mode, Submode_t submode);
-  virtual void startTransition(Mode_t mode, Submode_t submode) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl() override;
-  virtual void announceMode(bool recursive);
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  void setToExternalControl() override;
+  void announceMode(bool recursive) override;
   /** HK helpers */
   virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -6,7 +6,7 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t
       poolManager(this, commandQueue),
       actionHelper(this, commandQueue) {}
 
-ExtendedControllerBase::~ExtendedControllerBase() {}
+ExtendedControllerBase::~ExtendedControllerBase() = default;
 
 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
                                                     MessageQueueId_t commandedBy,
@@ -31,7 +31,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *messa
 
 void ExtendedControllerBase::handleQueue() {
   CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result;
   for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
        result = commandQueue->receiveMessage(&command)) {
     result = actionHelper.handleActionMessage(&command);

src/fsfw/controller/ExtendedControllerBase.h

@@ -18,16 +18,16 @@ class ExtendedControllerBase : public ControllerBase,
                                public HasLocalDataPoolIF {
  public:
   ExtendedControllerBase(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ExtendedControllerBase();
+  ~ExtendedControllerBase() override;
 
   /* SystemObjectIF overrides */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
   /* ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   LocalDataPoolManager poolManager;
@@ -39,31 +39,31 @@ class ExtendedControllerBase : public ControllerBase,
    * @param message
    * @return
    */
-  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override = 0;
 
   /**
    * Periodic helper from ControllerBase, implemented by child class.
    */
-  virtual void performControlOperation() = 0;
+  void performControlOperation() override = 0;
 
   /* Handle the four messages mentioned above */
   void handleQueue() override;
 
   /* HasActionsIF overrides */
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                               const uint8_t* data, size_t size) override;
 
   /* HasLocalDatapoolIF overrides */
-  virtual LocalDataPoolManager* getHkManagerHandle() override;
-  virtual object_id_t getObjectId() const override;
-  virtual uint32_t getPeriodicOperationFrequency() const override;
+  LocalDataPoolManager* getHkManagerHandle() override;
+  [[nodiscard]] object_id_t getObjectId() const override;
+  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
 
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override = 0;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 
   // Mode abstract functions
-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t* msToReachTheMode) override = 0;
 };
 

src/fsfw/datapool/DataSetIF.h

@@ -30,7 +30,7 @@ class DataSetIF {
    * @brief	This is an empty virtual destructor,
    * 			as it is proposed for C++ interfaces.
    */
-  virtual ~DataSetIF() {}
+  virtual ~DataSetIF() = default;
 
   /**
    * @brief	This operation provides a method to register local data pool
@@ -39,7 +39,7 @@ class DataSetIF {
    */
   virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
 
-  virtual uint16_t getFillCount() const = 0;
+  [[nodiscard]] virtual uint16_t getFillCount() const = 0;
 };
 
 #endif /* FSFW_DATAPOOL_DATASETIF_H_ */

src/fsfw/datapool/PoolDataSetBase.cpp

@@ -9,7 +9,7 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
                                  const size_t maxFillCount)
     : registeredVariables(registeredVariablesArray), maxFillCount(maxFillCount) {}
 
-PoolDataSetBase::~PoolDataSetBase() {}
+PoolDataSetBase::~PoolDataSetBase() = default;
 
 ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) {
   if (registeredVariables == nullptr) {

src/fsfw/datapool/PoolDataSetBase.h

@@ -64,7 +64,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
    *      commit() in between
    */
-  virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
                      uint32_t lockTimeout = 20) override;
   /**
    * @brief	The commit call initializes writing back the registered variables.
@@ -84,7 +84,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
    * 			  contains non write-only variables
    */
-  virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
                        uint32_t lockTimeout = 20) override;
 
   /**
@@ -92,30 +92,29 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * @param variable
    * @return
    */
-  virtual ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+  ReturnValue_t registerVariable(PoolVariableIF* variable) override;
 
   /**
    * Provides the means to lock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
    * @return Always returns -@c RETURN_OK
    */
-  virtual ReturnValue_t lockDataPool(
-      MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+  ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
                              uint32_t timeoutMs = 20) override;
   /**
    * Provides the means to unlock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
    * @return Always returns -@c RETURN_OK
    */
-  virtual ReturnValue_t unlockDataPool() override;
+  ReturnValue_t unlockDataPool() override;
 
-  virtual uint16_t getFillCount() const override;
+  [[nodiscard]] uint16_t getFillCount() const override;
 
   /* SerializeIF implementations */
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           SerializeIF::Endianness streamEndianness) const override;
-  virtual size_t getSerializedSize() const override;
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+  [[nodiscard]] size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                             SerializeIF::Endianness streamEndianness) override;
 
   /**
@@ -156,7 +155,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
   const size_t maxFillCount = 0;
 
   void setContainer(PoolVariableIF** variablesContainer);
-  PoolVariableIF** getContainer() const;
+  [[nodiscard]] PoolVariableIF** getContainer() const;
 
  private:
   bool protectEveryReadCommitCall = false;

src/fsfw/datapool/PoolEntry.cpp

@@ -11,7 +11,7 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid)
     : length(static_cast<uint8_t>(initValue.size())), valid(setValid) {
   this->address = new T[this->length];
   if (initValue.size() == 0) {
-    std::memset(this->address, 0, this->getByteSize());
+    std::memset(this->address, 0, PoolEntry<T>::getByteSize());
   } else {
     std::copy(initValue.begin(), initValue.end(), this->address);
   }
@@ -22,9 +22,9 @@ PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid)
     : length(setLength), valid(setValid) {
   this->address = new T[this->length];
   if (initValue != nullptr) {
-    std::memcpy(this->address, initValue, this->getByteSize());
+    std::memcpy(this->address, initValue, PoolEntry<T>::getByteSize());
   } else {
-    std::memset(this->address, 0, this->getByteSize());
+    std::memset(this->address, 0, PoolEntry<T>::getByteSize());
   }
 }
 
@@ -62,7 +62,7 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
-  const char* validString = nullptr;
+  const char* validString;
   if (valid) {
     validString = "Valid";
   } else {

src/fsfw/datapool/PoolEntry.h

@@ -62,7 +62,7 @@ class PoolEntry : public PoolEntryIF {
    * @param setValid
    * Sets the initialization flag. It is invalid by default.
    */
-  PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+  explicit PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
 
   //! Explicitely deleted copy ctor, copying is not allowed.
   PoolEntry(const PoolEntry&) = delete;
@@ -77,7 +77,7 @@ class PoolEntry : public PoolEntryIF {
    * PoolEntries shall never be copied, as a copy might delete the variable
    * on the heap.
    */
-  ~PoolEntry();
+  ~PoolEntry() override;
 
   /**
    * Return typed pointer to start of data.
@@ -91,32 +91,32 @@ class PoolEntry : public PoolEntryIF {
    * For non-array pool entries return type size, for vector entries
    * return type size times the number of entries.
    */
-  uint8_t getSize();
+  uint8_t getSize() override;
   /**
    * @brief	This operation returns the size in bytes.
    * @details	The size is calculated by sizeof(type) * array_size.
    */
-  uint16_t getByteSize();
+  uint16_t getByteSize() override;
   /**
    * @brief	This operation returns a the address pointer casted to void*.
    */
-  void* getRawData();
+  void* getRawData() override;
   /**
    * @brief	This method allows to set the valid information
    * 			of the pool entry.
    */
-  void setValid(bool isValid);
+  void setValid(bool isValid) override;
   /**
    * @brief	This method allows to get the valid information
    * 			of the pool entry.
    */
-  bool getValid();
+  bool getValid() override;
   /**
    * @brief	This is a debug method that prints all values and the valid
    * 			information to the screen. It prints all array entries in a row.
    */
-  void print();
-  Type getType();
+  void print() override;
+  Type getType() override;
 
  private:
   /**

src/fsfw/datapool/PoolEntryIF.h

@@ -24,7 +24,7 @@ class PoolEntryIF {
    * @brief	This is an empty virtual destructor,
    * 			as it is required for C++ interfaces.
    */
-  virtual ~PoolEntryIF() {}
+  virtual ~PoolEntryIF() = default;
   /**
    * @brief	getSize returns the array size of the entry.
    * 			A single variable parameter has size 1.

src/fsfw/datapool/PoolReadGuard.h

@@ -11,7 +11,7 @@
  */
 class PoolReadGuard {
  public:
-  PoolReadGuard(ReadCommitIF* readObject,
+  explicit PoolReadGuard(ReadCommitIF* readObject,
                          MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
                          uint32_t mutexTimeout = 20)
       : readObject(readObject), mutexTimeout(mutexTimeout) {
@@ -29,7 +29,7 @@ class PoolReadGuard {
     }
   }
 
-  ReturnValue_t getReadResult() const { return readResult; }
+  [[nodiscard]] ReturnValue_t getReadResult() const { return readResult; }
 
   /**
    * @brief   Can be used to suppress commit on destruction.

src/fsfw/datapool/PoolVarList.h

@@ -1,28 +0,0 @@
-#ifndef FSFW_DATAPOOL_POOLVARLIST_H_
-#define FSFW_DATAPOOL_POOLVARLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-template <class T, uint8_t n_var>
-class PoolVarList {
- private:
-  GlobPoolVar<T> variables[n_var];
-
- public:
-  PoolVarList(const uint32_t set_id[n_var], DataSetIF* dataSet,
-              PoolVariableIF::ReadWriteMode_t setReadWriteMode) {
-    // I really should have a look at the new init list c++ syntax.
-    if (dataSet == NULL) {
-      return;
-    }
-    for (uint8_t count = 0; count < n_var; count++) {
-      variables[count].dataPoolId = set_id[count];
-      variables[count].readWriteMode = setReadWriteMode;
-      dataSet->registerVariable(&variables[count]);
-    }
-  }
-
-  GlobPoolVar<T>& operator[](int i) { return variables[i]; }
-};
-
-#endif /* FSFW_DATAPOOL_POOLVARLIST_H_ */

src/fsfw/datapool/PoolVariableIF.h

@@ -24,8 +24,8 @@ class PoolVariableIF : public SerializeIF, public ReadCommitIF {
   static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
   static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
-  static constexpr bool VALID = 1;
-  static constexpr bool INVALID = 0;
+  static constexpr bool VALID = true;
+  static constexpr bool INVALID = false;
   static constexpr uint32_t NO_PARAMETER = 0xffffffff;
 
   enum ReadWriteMode_t { VAR_READ, VAR_WRITE, VAR_READ_WRITE };
@@ -34,23 +34,23 @@ class PoolVariableIF : public SerializeIF, public ReadCommitIF {
    * @brief	This is an empty virtual destructor,
    * 			as it is proposed for C++ interfaces.
    */
-  virtual ~PoolVariableIF() {}
+  ~PoolVariableIF() override = default;
   /**
    * @brief	This method returns if the variable is write-only,
    * 			read-write or read-only.
    */
-  virtual ReadWriteMode_t getReadWriteMode() const = 0;
+  [[nodiscard]] virtual ReadWriteMode_t getReadWriteMode() const = 0;
   virtual void setReadWriteMode(ReadWriteMode_t newMode) = 0;
 
   /**
    * @brief	This operation shall return the data pool id of the variable.
    */
-  virtual uint32_t getDataPoolId() const = 0;
+  [[nodiscard]] virtual uint32_t getDataPoolId() const = 0;
   /**
    * @brief	With this call, the valid information of the
    * 			variable is returned.
    */
-  virtual bool isValid() const = 0;
+  [[nodiscard]] virtual bool isValid() const = 0;
   /**
    * @brief	With this call, the valid information of the variable is set.
    */

src/fsfw/datapool/ReadCommitIF.h

@@ -12,7 +12,7 @@ class ReadCommitIF {
   friend class ReadCommitIFAttorney;
 
  public:
-  virtual ~ReadCommitIF() {}
+  virtual ~ReadCommitIF() = default;
   virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) = 0;
   virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) = 0;
 

src/fsfw/datapool/SharedDataSetIF.h

@@ -5,7 +5,7 @@
 
 class SharedDataSetIF {
  public:
-  virtual ~SharedDataSetIF(){};
+  virtual ~SharedDataSetIF() = default;
 
  private:
   virtual ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType,

src/fsfw/datapoollocal/AccessLocalPoolF.h

@@ -9,7 +9,8 @@ class MutexIF;
  */
 class AccessPoolManagerIF {
  public:
-  virtual ~AccessPoolManagerIF(){};
+  virtual ~AccessPoolManagerIF() = default;
+  ;
 
   virtual MutexIF* getLocalPoolMutex() = 0;
 

src/fsfw/datapoollocal/HasLocalDataPoolIF.h

@@ -44,14 +44,15 @@ class HasLocalDataPoolIF {
   friend class HasLocalDpIFUserAttorney;
 
  public:
-  virtual ~HasLocalDataPoolIF(){};
+  virtual ~HasLocalDataPoolIF() = default;
+  ;
 
   static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-  virtual object_id_t getObjectId() const = 0;
+  [[nodiscard]] virtual object_id_t getObjectId() const = 0;
 
   /** Command queue for housekeeping messages. */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
 
   /**
    * Is used by pool owner to initialize the pool map once
@@ -66,7 +67,7 @@ class HasLocalDataPoolIF {
    * usually be the period the pool owner performs its periodic operation.
    * @return
    */
-  virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+  [[nodiscard]] virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
 
   /**
    * @brief   This function will be called by the manager if an update

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -1,6 +1,5 @@
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 
-#include <array>
 #include <cmath>
 
 #include "fsfw/datapoollocal.h"
@@ -57,7 +56,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   }
 
   if (defaultHkDestination != objects::NO_OBJECT) {
-    AcceptsHkPacketsIF* hkPacketReceiver =
+    auto* hkPacketReceiver =
         ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
     if (hkPacketReceiver != nullptr) {
       hkDestinationId = hkPacketReceiver->getHkQueue();
@@ -209,9 +208,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     /* Prepare and send update snapshot */
-    timeval now;
+    timeval now{};
     Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds;
+    CCSDSTime::CDS_short cds{};
     CCSDSTime::convertToCcsds(&cds, &now);
     HousekeepingSnapshot updatePacket(
         reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@@ -245,9 +244,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     /* Prepare and send update snapshot */
-    timeval now;
+    timeval now{};
     Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds;
+    CCSDSTime::CDS_short cds{};
     CCSDSTime::convertToCcsds(&cds, &now);
     HousekeepingSnapshot updatePacket(
         reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@@ -339,8 +338,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
                                                                float collectionInterval,
                                                                bool isDiagnostics,
                                                                object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
+  auto* hkReceiverObject = ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
@@ -368,8 +366,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid, bool isDiagnostics,
                                                              bool reportingEnabled,
                                                              object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
+  auto* hkReceiverObject = ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
@@ -696,7 +693,8 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed." << std::endl;
+    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
+                 << std::endl;
 #else
     sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
 #endif

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -80,7 +80,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    */
   LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
                        bool appendValidityBuffer = true);
-  virtual ~LocalDataPoolManager();
+  ~LocalDataPoolManager() override;
 
   /**
    * Assigns the queue to use. Make sure to call this in the #initialize
@@ -151,7 +151,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    * Otherwise, only an notification message is sent.
    * @return
    */
-  ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId, object_id_t destinationObject,
+  ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
                                              MessageQueueId_t targetQueueId,
                                              bool generateSnapshot) override;
 
@@ -169,7 +169,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    * Otherwise, only an notification message is sent.
    * @return
    */
-  ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+  ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
                                                   object_id_t destinationObject,
                                                   MessageQueueId_t targetQueueId,
                                                   bool generateSnapshot) override;
@@ -252,7 +252,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    */
   void clearReceiversList();
 
-  object_id_t getCreatorObjectId() const;
+  [[nodiscard]] object_id_t getCreatorObjectId() const;
 
   /**
    * Get the pointer to the mutex. Can be used to lock the data pool
@@ -262,7 +262,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    */
   MutexIF* getMutexHandle();
 
-  virtual LocalDataPoolManager* getPoolManagerHandle() override;
+  LocalDataPoolManager* getPoolManagerHandle() override;
 
  protected:
   /** Core data structure for the actual pool data */
@@ -306,8 +306,8 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   struct HkUpdateResetHelper {
     DataType dataType = DataType::DATA_SET;
     DataId dataId;
-    uint8_t updateCounter;
-    uint8_t currentUpdateCounter;
+    uint8_t updateCounter{};
+    uint8_t currentUpdateCounter{};
   };
 
   using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -207,13 +207,11 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
-  HealthState getHealth();
-  ReturnValue_t setHealth(HealthState health);
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues,
-                                     uint16_t startAtIndex) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  HealthState getHealth() override;
+  ReturnValue_t setHealth(HealthState health) override;
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
+                             const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 
  protected:
   /**
@@ -1042,11 +1040,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   bool isAwaitingReply();
 
   void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId, 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);
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t *msToReachTheMode) override;
 
   virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
@@ -1062,8 +1058,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /**
    * Same as triggerEvent, but for forwarding if object is used as proxy.
    */
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
-                            uint32_t parameter2 = 0) const override;
+  void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
 
   /**
    * Checks if current mode is transitional mode.

src/fsfw/health/HasHealthIF.h

@@ -36,7 +36,7 @@ class HasHealthIF {
       12,
       severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
 
-  virtual ~HasHealthIF() {}
+  virtual ~HasHealthIF() = default;
 
   virtual MessageQueueId_t getCommandQueue() const = 0;
 

src/fsfw/housekeeping/HousekeepingSnapshot.h

@@ -55,7 +55,7 @@ class HousekeepingSnapshot : public SerializeIF {
       : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr){};
 
   virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
+                                  Endianness streamEndianness) const override {
     if (timeStamp != nullptr) {
       /* Endianness will always be MACHINE, so we can simply use memcpy
       here. */
@@ -70,7 +70,7 @@ class HousekeepingSnapshot : public SerializeIF {
     return updateData->serialize(buffer, size, maxSize, streamEndianness);
   }
 
-  virtual size_t getSerializedSize() const {
+  virtual size_t getSerializedSize() const override {
     if (updateData == nullptr) {
       return 0;
     }

src/fsfw/ipc/MessageQueueBase.h

@@ -10,25 +10,25 @@ class MessageQueueBase : public MessageQueueIF {
   virtual ~MessageQueueBase();
 
   // Default implementations for MessageQueueIF where possible
-  virtual MessageQueueId_t getLastPartner() const override;
-  virtual MessageQueueId_t getId() const override;
-  virtual MqArgs& getMqArgs() override;
-  virtual void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-  virtual MessageQueueId_t getDefaultDestination() const override;
-  virtual bool isDefaultDestinationSet() const override;
-  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+  MessageQueueId_t getLastPartner() const override;
+  MessageQueueId_t getId() const override;
+  MqArgs& getMqArgs() override;
+  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+  MessageQueueId_t getDefaultDestination() const override;
+  bool isDefaultDestinationSet() const override;
+  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                             bool ignoreFault) override;
-  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+  ReturnValue_t reply(MessageQueueMessageIF* message) override;
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
                                MessageQueueId_t* receivedFrom) override;
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+  ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
                                   bool ignoreFault = false) override;
 
   // OSAL specific, forward the abstract function
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom, bool ignoreFault = false) = 0;
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override = 0;
+  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override = 0;
 
  protected:
   MessageQueueId_t id = MessageQueueIF::NO_QUEUE;

src/fsfw/monitoring/AbsLimitMonitor.h

@@ -17,8 +17,8 @@ class AbsLimitMonitor : public MonitorBase<T> {
         limit(limit),
         violationEvent(violationEvent),
         aboveIsViolation(aboveIsViolation) {}
-  virtual ~AbsLimitMonitor() {}
-  virtual ReturnValue_t checkSample(T sample, T *crossedLimit) {
+  virtual ~AbsLimitMonitor() = default;
+  ReturnValue_t checkSample(T sample, T *crossedLimit) override {
     *crossedLimit = limit;
     if (aboveIsViolation) {
       if ((std::abs(sample) > limit)) {
@@ -32,9 +32,9 @@ class AbsLimitMonitor : public MonitorBase<T> {
     return HasReturnvaluesIF::RETURN_OK;  // We're not out of range.
   }
 
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t parameterId,
+                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+                             uint16_t startAtIndex) override {
     ReturnValue_t result = this->MonitorBase<T>::getParameter(
         domainId, parameterId, parameterWrapper, newValues, startAtIndex);
     // We'll reuse the DOMAIN_ID of MonitorReporter,
@@ -61,7 +61,7 @@ class AbsLimitMonitor : public MonitorBase<T> {
   void setLimit(T value) { limit = value; }
 
  protected:
-  void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+  void sendTransitionEvent(T currentValue, ReturnValue_t state) override {
     switch (state) {
       case MonitoringIF::OUT_OF_RANGE:
         EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->globalPoolId.objectId,

src/fsfw/monitoring/MonitorReporter.h

@@ -51,9 +51,8 @@ class MonitorReporter : public HasParametersIF {
     return state;
   }
 
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
+                             const ParameterWrapper *newValues, uint16_t startAtIndex) override {
     if (domainId != monitorId) {
       return INVALID_DOMAIN_ID;
     }

src/fsfw/osal/linux/FixedTimeslotTask.cpp

@@ -54,7 +54,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
       // If the deadline was missed, the deadlineMissedFunc is called.
       if (!PosixThread::delayUntil(&lastWakeTime, interval)) {
         // No time left on timer -> we missed the deadline
-        if(dlmFunc != nullptr){
+        if (dlmFunc != nullptr) {
           dlmFunc();
         }
       }

src/fsfw/parameters/HasParametersIF.h

@@ -51,7 +51,7 @@ class HasParametersIF {
     return (domainId << 24) + (uniqueId << 16) + linearIndex;
   }
 
-  virtual ~HasParametersIF() {}
+  virtual ~HasParametersIF() = default;
 
   /**
    * This is the generic function overriden by child classes to set

src/fsfw/power/Fuse.h

@@ -63,13 +63,13 @@ class Fuse : public SystemObject,
                             SerializeIF::Endianness streamEndianness) override;
   void setAllMonitorsToUnchecked();
   ReturnValue_t performOperation(uint8_t opCode);
-  MessageQueueId_t getCommandQueue() const;
+  MessageQueueId_t getCommandQueue() const override;
   void setDataPoolEntriesInvalid();
-  ReturnValue_t setHealth(HealthState health);
-  HasHealthIF::HealthState getHealth();
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;
 
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper *parameterWrapper,
-                             const ParameterWrapper *newValues, uint16_t startAtIndex);
+                             const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 
  private:
   uint8_t oldFuseState;
@@ -81,7 +81,7 @@ class Fuse : public SystemObject,
     template <typename... Args>
     PowerMonitor(Args... args) : MonitorReporter<float>(std::forward<Args>(args)...) {}
     ReturnValue_t checkPower(float sample, float lowerLimit, float upperLimit);
-    void sendTransitionEvent(float currentValue, ReturnValue_t state) {}
+    void sendTransitionEvent(float currentValue, ReturnValue_t state_) override {}
   };
   PowerMonitor powerMonitor;
   StaticLocalDataSet<3> set;

src/fsfw/power/PowerComponent.h

@@ -10,15 +10,15 @@ class PowerComponent : public PowerComponentIF {
   PowerComponent(object_id_t setId, uint8_t moduleId, float minPower, float maxPower,
                  uint8_t switchId1, bool twoSwitches = false, uint8_t switchId2 = 0xFF);
 
-  virtual object_id_t getDeviceObjectId();
+  object_id_t getDeviceObjectId() override;
 
-  virtual uint8_t getSwitchId1();
-  virtual uint8_t getSwitchId2();
+  uint8_t getSwitchId1() override;
+  uint8_t getSwitchId2() override;
 
-  bool hasTwoSwitches();
+  bool hasTwoSwitches() override;
 
-  float getMin();
-  float getMax();
+  float getMin() override;
+  float getMax() override;
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;
@@ -29,7 +29,7 @@ class PowerComponent : public PowerComponentIF {
                             Endianness streamEndianness) override;
 
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
-                             const ParameterWrapper* newValues, uint16_t startAtIndex);
+                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
 
  private:
   const object_id_t deviceObjectId = objects::NO_OBJECT;

src/fsfw/power/PowerComponentIF.h

@@ -7,7 +7,7 @@
 
 class PowerComponentIF : public SerializeIF, public HasParametersIF {
  public:
-  virtual ~PowerComponentIF() {}
+  ~PowerComponentIF() override = default;
 
   virtual object_id_t getDeviceObjectId() = 0;
 

src/fsfw/pus/servicepackets/Service1Packets.h

@@ -69,7 +69,7 @@ class FailureReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
     return result;
   }
 
-  virtual size_t getSerializedSize() const {
+  size_t getSerializedSize() const override {
     size_t size = 0;
     size += SerializeAdapter::getSerializedSize(&packetId);
     size += sizeof(packetSequenceControl);

src/fsfw/serialize/SerializeIF.h

@@ -34,7 +34,7 @@ class SerializeIF {
   static const ReturnValue_t TOO_MANY_ELEMENTS =
       MAKE_RETURN_CODE(3);  // !< There are too many elements to be deserialized
 
-  virtual ~SerializeIF() {}
+  virtual ~SerializeIF() = default;
   /**
    * @brief
    * Function to serialize the object into a buffer with maxSize. Size represents the written
@@ -66,7 +66,7 @@ class SerializeIF {
    * Gets the size of a object if it would be serialized in a buffer
    * @return Size of serialized object
    */
-  virtual size_t getSerializedSize() const = 0;
+  [[nodiscard]] virtual size_t getSerializedSize() const = 0;
 
   /**
    * @brief

src/fsfw/storagemanager/StorageAccessor.cpp

@@ -10,7 +10,7 @@ StorageAccessor::StorageAccessor(store_address_t storeId) : ConstStorageAccessor
 StorageAccessor::StorageAccessor(store_address_t storeId, StorageManagerIF* store)
     : ConstStorageAccessor(storeId, store) {}
 
-StorageAccessor& StorageAccessor::operator=(StorageAccessor&& other) {
+StorageAccessor& StorageAccessor::operator=(StorageAccessor&& other) noexcept {
   // Call the parent move assignment and also assign own member.
   dataPointer = other.dataPointer;
   ConstStorageAccessor::operator=(std::move(other));
@@ -18,7 +18,7 @@ StorageAccessor& StorageAccessor::operator=(StorageAccessor&& other) {
 }
 
 // Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other)
+StorageAccessor::StorageAccessor(StorageAccessor&& other) noexcept
     : ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {}
 
 ReturnValue_t StorageAccessor::getDataCopy(uint8_t* pointer, size_t maxSize) {

src/fsfw/storagemanager/StorageAccessor.h

@@ -14,7 +14,7 @@ class StorageAccessor : public ConstStorageAccessor {
   friend class LocalPool;
 
  public:
-  StorageAccessor(store_address_t storeId);
+  explicit StorageAccessor(store_address_t storeId);
   StorageAccessor(store_address_t storeId, StorageManagerIF* store);
 
   /**
@@ -25,8 +25,8 @@ class StorageAccessor : public ConstStorageAccessor {
    * @param
    * @return
    */
-  StorageAccessor& operator=(StorageAccessor&&);
-  StorageAccessor(StorageAccessor&&);
+  StorageAccessor& operator=(StorageAccessor&&) noexcept;
+  StorageAccessor(StorageAccessor&&) noexcept;
 
   ReturnValue_t write(uint8_t* data, size_t size, uint16_t offset = 0);
   uint8_t* data();

src/fsfw/tcdistribution/CFDPDistributor.cpp

@@ -29,11 +29,11 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
                   storeId.packetIndex);
 #endif
 #endif
-  TcMqMapIter queueMapIt = this->queueMap.end();
+  auto queueMapIt = this->queueMap.end();
   if (this->currentPacket == nullptr) {
     return queueMapIt;
   }
-  this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+  this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
   if (currentPacket->getWholeData() != nullptr) {
     tcStatus = checker.checkPacket(currentPacket);
     if (tcStatus != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/thermal/Heater.cpp

@@ -190,13 +190,13 @@ ReturnValue_t Heater::performOperation(uint8_t opCode) {
 }
 
 void Heater::setSwitch(uint8_t number, ReturnValue_t state, uint32_t* uptimeOfSwitching) {
-  if (powerSwitcher == NULL) {
+  if (powerSwitcher == nullptr) {
     return;
   }
   if (powerSwitcher->getSwitchState(number) == state) {
     *uptimeOfSwitching = INVALID_UPTIME;
   } else {
-    if ((*uptimeOfSwitching == INVALID_UPTIME)) {
+    if (*uptimeOfSwitching == INVALID_UPTIME) {
       powerSwitcher->sendSwitchCommand(number, state);
       Clock::getUptime(uptimeOfSwitching);
     } else {

src/fsfw/tmtcpacket/cfdp/CFDPPacket.h

@@ -11,11 +11,11 @@ class CFDPPacket : public SpacePacketBase {
    * forwards the data pointer to the parent SpacePacketBase class.
    * @param setData	The position where the packet data lies.
    */
-  CFDPPacket(const uint8_t* setData);
+  explicit CFDPPacket(const uint8_t* setData);
   /**
    * This is the empty default destructor.
    */
-  virtual ~CFDPPacket();
+  ~CFDPPacket() override;
 
   /**
    * This is a debugging helper method that prints the whole packet content

src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.cpp

@@ -2,48 +2,44 @@
 
 #include "fsfw/objectmanager/ObjectManager.h"
 
-StorageManagerIF* CFDPPacketStored::store = nullptr;
-
 CFDPPacketStored::CFDPPacketStored() : CFDPPacket(nullptr) {}
 
 CFDPPacketStored::CFDPPacketStored(store_address_t setAddress) : CFDPPacket(nullptr) {
-  this->setStoreAddress(setAddress);
+  CFDPPacketStored::setStoreAddress(setAddress, this);
 }
 
 CFDPPacketStored::CFDPPacketStored(const uint8_t* data, size_t size) : CFDPPacket(data) {
   if (this->getFullSize() != size) {
     return;
   }
-  if (this->checkAndSetStore()) {
-    ReturnValue_t status = store->addData(&storeAddress, data, size);
+  if (CFDPPacketStored::checkAndSetStore()) {
+    ReturnValue_t status = STORE->addData(&storeAddress, data, size);
     if (status != HasReturnvaluesIF::RETURN_OK) {
       this->setData(nullptr, -1);
     }
     const uint8_t* storePtr = nullptr;
     // Repoint base data pointer to the data in the store.
-    store->getData(storeAddress, &storePtr, &size);
+    STORE->getData(storeAddress, &storePtr, &size);
     this->setData(const_cast<uint8_t*>(storePtr), size);
   }
 }
 
 ReturnValue_t CFDPPacketStored::deletePacket() {
-  ReturnValue_t result = this->store->deleteData(this->storeAddress);
+  ReturnValue_t result = CFDPPacketStored::STORE->deleteData(this->storeAddress);
   this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
   // To circumvent size checks
   this->setData(nullptr, -1);
   return result;
 }
 
-// CFDPPacket* CFDPPacketStored::getPacketBase() {
-//     return this;
-// }
-void CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
+void CFDPPacketStored::setStoreAddress(store_address_t setAddress,
+                                       RedirectableDataPointerIF* packet) {
   this->storeAddress = setAddress;
   const uint8_t* tempData = nullptr;
   size_t tempSize;
   ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
-  if (this->checkAndSetStore()) {
-    status = this->store->getData(this->storeAddress, &tempData, &tempSize);
+  if (CFDPPacketStored::checkAndSetStore()) {
+    status = CFDPPacketStored::STORE->getData(this->storeAddress, &tempData, &tempSize);
   }
   if (status == StorageManagerIF::RETURN_OK) {
     this->setData(const_cast<uint8_t*>(tempData), tempSize);
@@ -56,33 +52,17 @@ void CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
 
 store_address_t CFDPPacketStored::getStoreAddress() { return this->storeAddress; }
 
-CFDPPacketStored::~CFDPPacketStored() {}
+CFDPPacketStored::~CFDPPacketStored() = default;
 
 ReturnValue_t CFDPPacketStored::getData(const uint8_t** dataPtr, size_t* dataSize) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-// ReturnValue_t CFDPPacketStored::setData(const uint8_t *data) {
-//     return HasReturnvaluesIF::RETURN_OK;
-// }
-
-bool CFDPPacketStored::checkAndSetStore() {
-  if (this->store == nullptr) {
-    this->store = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
-    if (this->store == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "CFDPPacketStored::CFDPPacketStored: TC Store not found!" << std::endl;
-#endif
-      return false;
-    }
-  }
-  return true;
-}
-
 bool CFDPPacketStored::isSizeCorrect() {
   const uint8_t* temp_data = nullptr;
   size_t temp_size;
-  ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data, &temp_size);
+  ReturnValue_t status =
+      CFDPPacketStored::STORE->getData(this->storeAddress, &temp_data, &temp_size);
   if (status == StorageManagerIF::RETURN_OK) {
     if (this->getFullSize() == temp_size) {
       return true;

src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.h

@@ -16,10 +16,10 @@ class CFDPPacketStored : public CFDPPacket, public TcPacketStoredBase {
    * Create stored packet from existing packet in store
    * @param setAddress
    */
-  CFDPPacketStored(store_address_t setAddress);
+  explicit CFDPPacketStored(store_address_t setAddress);
   CFDPPacketStored();
 
-  virtual ~CFDPPacketStored();
+  ~CFDPPacketStored() override;
 
   /**
    * Getter function for the raw data.
@@ -27,37 +27,22 @@ class CFDPPacketStored : public CFDPPacket, public TcPacketStoredBase {
    * @param dataSize [out] Address of size to set.
    * @return -@c RETURN_OK if data was retrieved successfully.
    */
-  ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize);
+  ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize) override;
 
-  void setStoreAddress(store_address_t setAddress);
+  void setStoreAddress(store_address_t setAddress, RedirectableDataPointerIF* packet) override;
 
-  store_address_t getStoreAddress();
+  store_address_t getStoreAddress() override;
 
-  ReturnValue_t deletePacket();
+  ReturnValue_t deletePacket() override;
 
  private:
-  bool isSizeCorrect();
+  bool isSizeCorrect() override;
 
  protected:
-  /**
-   * This is a pointer to the store all instances of the class use.
-   * If the store is not yet set (i.e. @c store is NULL), every constructor
-   * call tries to set it and throws an error message in case of failures.
-   * The default store is objects::TC_STORE.
-   */
-  static StorageManagerIF* store;
   /**
    * The address where the packet data of the object instance is stored.
    */
   store_address_t storeAddress;
-  /**
-   * A helper method to check if a store is assigned to the class.
-   * If not, the method tries to retrieve the store from the global
-   * ObjectManager.
-   * @return  @li @c true if the store is linked or could be created.
-   *          @li @c false otherwise.
-   */
-  bool checkAndSetStore();
 };
 
 #endif /* FSFW_INC_FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_ */

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h

@@ -19,7 +19,7 @@ class TcPacketStoredBase : public TcPacketStoredIF {
    * Constructor to set to an existing store address.
    * @param setAddress
    */
-  TcPacketStoredBase(store_address_t setAddress);
+  explicit TcPacketStoredBase(store_address_t setAddress);
   /**
    * Another constructor to create a TcPacket from a raw packet stream.
    * Takes the data and adds it unchecked to the TcStore.
@@ -28,7 +28,7 @@ class TcPacketStoredBase : public TcPacketStoredIF {
    */
   TcPacketStoredBase(const uint8_t* data, uint32_t size);
 
-  virtual ~TcPacketStoredBase();
+  ~TcPacketStoredBase() override;
 
   /**
    * Getter function for the raw data.
@@ -70,6 +70,7 @@ class TcPacketStoredBase : public TcPacketStoredIF {
    * The address where the packet data of the object instance is stored.
    */
   store_address_t storeAddress;
+
   /**
    * A helper method to check if a store is assigned to the class.
    * If not, the method tries to retrieve the store from the global

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredIF.h

@@ -16,6 +16,8 @@ class TcPacketStoredIF {
    * With this call, the stored packet can be set to another packet in a store. This is useful
    * if the packet is a class member and used for more than one packet.
    * @param setAddress    The new packet id to link to.
+   * @param packet        Explicit packet instance. The setData function should be called on this
+   * pointer
    */
   virtual void setStoreAddress(store_address_t setAddress, RedirectableDataPointerIF* packet) = 0;
 

tests/src/fsfw_tests/internal/serialize/IntTestSerialization.cpp

@@ -147,8 +147,9 @@ ReturnValue_t testserialize::test_autoserialization() {
   }
 
   // These epsilon values were just guessed.. It appears to work though.
-  if (abs(tv_float - tv::tv_float) > 0.0001 or abs(tv_double - tv::tv_double) > 0.01 or
-      abs(tv_sfloat - tv::tv_sfloat) > 0.0001 or abs(tv_sdouble - tv::tv_sdouble) > 0.01) {
+  if (std::abs(tv_float - tv::tv_float) > 0.0001 or std::abs(tv_double - tv::tv_double) > 0.01 or
+      std::abs(tv_sfloat - tv::tv_sfloat) > 0.0001 or
+      std::abs(tv_sdouble - tv::tv_sdouble) > 0.01) {
     return unitt::put_error(id);
   }
 

tests/src/fsfw_tests/unit/hal/testCommandExecutor.cpp

@@ -4,12 +4,12 @@
 #include <fstream>
 #include <iostream>
 
-#include "tests/TestsConfig.h"
 #include "fsfw/container/DynamicFIFO.h"
 #include "fsfw/container/SimpleRingBuffer.h"
 #include "fsfw/platform.h"
 #include "fsfw/serviceinterface.h"
 #include "fsfw_hal/linux/CommandExecutor.h"
+#include "tests/TestsConfig.h"
 
 #ifdef PLATFORM_UNIX
 

tests/src/fsfw_tests/unit/storagemanager/TestNewAccessor.cpp

@@ -157,7 +157,7 @@ TEST_CASE("New Accessor", "[NewAccessor]") {
     }
   }
 
-  SECTION("Operators"){
+  SECTION("Operators") {
     result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
     REQUIRE(result == retval::CATCH_OK);
     {
@@ -176,10 +176,10 @@ TEST_CASE("New Accessor", "[NewAccessor]") {
 
       std::array<uint8_t, 10> newData;
       // Expect data to be invalid so this must return RETURN_FAILED
-      result = accessor.getDataCopy(newData.data(),newData.size());
+      result = accessor.getDataCopy(newData.data(), newData.size());
       REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
       // Expect data to be too small
-      result = accessor2.getDataCopy(data.data(),data.size());
+      result = accessor2.getDataCopy(data.data(), data.size());
       REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
     }
   }

tests/src/fsfw_tests/unit/storagemanager/TestPool.cpp

@@ -1,9 +1,9 @@
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
 
+#include <array>
 #include <catch2/catch_test_macros.hpp>
 #include <cstring>
-#include <array>
 
 #include "fsfw_tests/unit/CatchDefinitions.h"