Merge branch 'mueller/refactor-tmtc-stack' into mueller/cfdp-routers

CHANGELOG.md

@@ -10,12 +10,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [v6.0.0]
 
+## Changes
+
 ## Added
 
 - Add new `UnsignedByteField` class
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
 
 ## Changes
 
+- Removed `HasReturnvaluesIF` class in favor of `returnvalue` namespace with `OK` and `FAILED`
+  constants.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/659
 - Overhaul of the TMTC stack, including various changes and improvements
   for other modules
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/655
@@ -37,7 +43,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - HAL Devicehandlers: Periodic printout is run-time configurable now
 - `oneShotAction` flag in the `TestTask` class is not static anymore
 - `SimpleRingBuffer::writeData` now checks if the amount is larger than the total size of the 
-  Buffer and rejects such writeData calls with `HasReturnvaluesIF::RETURN_FAILED`
+  Buffer and rejects such writeData calls with `returnvalue::FAILED`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586
 - Major update for version handling, using `git describe` to fetch version information with git.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601

docs/README-highlevel.md

@@ -14,7 +14,7 @@ FSFW to achieve that. The fsfw uses run-time type information but exceptions are
 # Failure Handling
 
 Functions should return a defined `ReturnValue_t` to signal to the caller that something has
-gone wrong. Returnvalues must be unique. For this the function `HasReturnvaluesIF::makeReturnCode`
+gone wrong. Returnvalues must be unique. For this the function `returnvalue::makeCode`
 or the macro `MAKE_RETURN` can be used. The `CLASS_ID` is a unique id for that type of object.
 See `returnvalues/FwClassIds` folder. The user can add custom `CLASS_ID`s via the
 `fsfwconfig` folder.

docs/README-localpools.md

@@ -144,7 +144,7 @@ ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDat
 			new PoolEntry<uint8_t>({0}));
 
 	poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
-	return HasReturnvaluesIF::RETURN_OK;
+	return returnvalue::OK;
 }
 ```
 
@@ -154,7 +154,7 @@ in any case:
 
 ```cpp
 PoolReadGuard readHelper(&gyroData);
-if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+if(readHelper.getReadResult() == returnvalue::OK) {
 	if(not gyroData.isValid()) {
 		gyroData.setValidity(true, true);
 	}

docs/api/returnvalue.rst

@@ -3,7 +3,7 @@
 Returnvalue API
 ==================
 
-.. doxygenfile:: HasReturnvaluesIF.h
+.. doxygenfile:: returnvalue.h
 
 .. _fwclassids:
 

docs/devicehandlers.rst

@@ -75,11 +75,11 @@ and the respective source file with sensible default return values:
 	void TestDeviceHandler::doShutDown() {}
 
 	ReturnValue_t TestDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-	  return HasReturnvaluesIF::RETURN_OK;
+	  return returnvalue::OK;
 	}
 
 	ReturnValue_t TestDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-	  return HasReturnvaluesIF::RETURN_OK;
+	  return returnvalue::OK;
 	}
 
 	void TestDeviceHandler::fillCommandAndReplyMap() {}
@@ -87,17 +87,17 @@ and the respective source file with sensible default return values:
 	ReturnValue_t TestDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 	                                                         const uint8_t* commandData,
 	                                                         size_t commandDataLen) {
-	  return HasReturnvaluesIF::RETURN_OK;
+	  return returnvalue::OK;
 	}
 
 	ReturnValue_t TestDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
 	                                              DeviceCommandId_t* foundId, size_t* foundLen) {
-	  return HasReturnvaluesIF::RETURN_OK;
+	  return returnvalue::OK;
 	}
 
 	ReturnValue_t TestDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
 	                                                      const uint8_t* packet) {
-	  return HasReturnvaluesIF::RETURN_OK;
+	  return returnvalue::OK;
 	}
 
 	uint32_t TestDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
@@ -106,5 +106,5 @@ and the respective source file with sensible default return values:
 
 	ReturnValue_t TestDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 	                                                         LocalDataPoolManager& poolManager) {
-	  return HasReturnvaluesIF::RETURN_OK;
+	  return returnvalue::OK;
 	}

docs/highlevel.rst

@@ -20,7 +20,7 @@ Failure Handling
 -----------------
 
 Functions should return a defined :cpp:type:`ReturnValue_t` to signal to the caller that something has
-gone wrong. Returnvalues must be unique. For this the function :cpp:func:`HasReturnvaluesIF::makeReturnCode`
+gone wrong. Returnvalues must be unique. For this the function :cpp:func:`returnvalue::makeCode`
 or the :ref:`macro MAKE_RETURN_CODE <retvalapi>` can be used. The ``CLASS_ID`` is a unique ID for that type of object.
 See the :ref:`FSFW Class IDs file <fwclassids>`. The user can add custom ``CLASS_ID``\s via the
 ``fsfwconfig`` folder.

docs/localpools.rst

@@ -150,7 +150,7 @@ with a housekeeping service command.
 				new PoolEntry<uint8_t>({0}));
 
 		poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
-		return HasReturnvaluesIF::RETURN_OK;
+		return returnvalue::OK;
 	}
 
 Now, if we receive some sensor data and converted them into the right format,
@@ -160,7 +160,7 @@ in any case:
 .. code-block:: cpp
 
 	PoolReadGuard readHelper(&gyroData);
-	if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+	if(readHelper.getReadResult() == returnvalue::OK) {
 		if(not gyroData.isValid()) {
 			gyroData.setValidity(true, true);
 		}

misc/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp

@@ -11,15 +11,15 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 
 	/* Add polling sequence table here */
 
-	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
-		return HasReturnvaluesIF::RETURN_OK;
+	if (thisSequence->checkSequence() == returnvalue::OK) {
+		return returnvalue::OK;
 	}
 	else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
 #endif
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return returnvalue::FAILED;
 	}
 }
 

misc/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h

@@ -1,7 +1,7 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_
 
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
 
 class FixedTimeslotTaskIF;
 

src/fsfw/action/ActionHelper.cpp

@@ -12,7 +12,7 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
   if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
     ActionId_t currentAction = ActionMessage::getActionId(command);
     prepareExecution(command->getSender(), currentAction, ActionMessage::getStoreId(command));
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   } else {
     return CommandMessage::UNKNOWN_COMMAND;
   }
@@ -21,7 +21,7 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   if (ipcStore == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (queueToUse_ != nullptr) {
     setQueueToUse(queueToUse_);
@@ -35,10 +35,10 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
     sif::printWarning("ActionHelper::initialize: No queue set\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId,
@@ -62,7 +62,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
   const uint8_t* dataPtr = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     CommandMessage reply;
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
@@ -75,7 +75,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
     ActionMessage::setCompletionReply(&reply, actionId, true, result);
     queueToUse->sendMessage(commandedBy, &reply);
   }
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     CommandMessage reply;
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
@@ -91,11 +91,11 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   size_t maxSize = data->getSerializedSize();
   if (maxSize == 0) {
     /* No error, there's simply nothing to report. */
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
   size_t size = 0;
   ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize, &dataPtr);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ActionHelper::reportData: Getting free element from IPC store failed!"
                  << std::endl;
@@ -107,7 +107,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
     return result;
   }
   result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ipcStore->deleteData(storeAddress);
     return result;
   }
@@ -124,7 +124,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
     result = queueToUse->sendMessage(reportTo, &reply);
   }
 
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ipcStore->deleteData(storeAddress);
   }
   return result;
@@ -137,7 +137,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   CommandMessage reply;
   store_address_t storeAddress;
   ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ActionHelper::reportData: Adding data to IPC store failed!" << std::endl;
 #else
@@ -158,7 +158,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
     result = queueToUse->sendMessage(reportTo, &reply);
   }
 
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ipcStore->deleteData(storeAddress);
   }
   return result;

src/fsfw/action/ActionHelper.h

@@ -36,7 +36,7 @@ class ActionHelper {
    * send to the sender of the message automatically.
    *
    * @param command Pointer to a command message received by the owner
-   * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+   * @return returnvalue::OK if the message is a action message,
    *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
    */
   ReturnValue_t handleActionMessage(CommandMessage* command);
@@ -45,7 +45,7 @@ class ActionHelper {
    * helper function
    * @param queueToUse_   Pointer to the messageQueue to be used, optional
    *                      if queue was set in constructor
-   * @return Returns RETURN_OK if successful
+   * @return Returns returnvalue::OK if successful
    */
   ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
   /**
@@ -58,7 +58,7 @@ class ActionHelper {
    * @param result Result of the execution
    */
   void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId,
-            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+            ReturnValue_t result = returnvalue::OK);
   /**
    * Function to be called by the owner to send a action completion message
    * @param success   Specify whether action was completed successfully or not.
@@ -67,7 +67,7 @@ class ActionHelper {
    * @param result Result of the execution
    */
   void finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
-              ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+              ReturnValue_t result = returnvalue::OK);
   /**
    * Function to be called by the owner if an action does report data.
    * Takes a SerializeIF* pointer and serializes it into the IPC store.
@@ -75,7 +75,7 @@ class ActionHelper {
    *                  message to
    * @param replyId ID of the executed command
    * @param data Pointer to the data
-   * @return Returns RETURN_OK if successful, otherwise failure code
+   * @return Returns returnvalue::OK if successful, otherwise failure code
    */
   ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data,
                            bool hideSender = false);
@@ -86,7 +86,7 @@ class ActionHelper {
    *                  message to
    * @param replyId ID of the executed command
    * @param data Pointer to the data
-   * @return Returns RETURN_OK if successful, otherwise failure code
+   * @return Returns returnvalue::OK if successful, otherwise failure code
    */
   ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, const uint8_t* data,
                            size_t dataSize, bool hideSender = false);

src/fsfw/action/ActionMessage.cpp

@@ -25,7 +25,7 @@ store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
 
 void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
                                  ReturnValue_t result) {
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
     message->setCommand(STEP_SUCCESS);
   } else {
     message->setCommand(STEP_FAILED);

src/fsfw/action/ActionMessage.h

@@ -33,12 +33,12 @@ class ActionMessage {
   static store_address_t getStoreId(const CommandMessage* message);
 
   static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-                           ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+                           ReturnValue_t result = returnvalue::OK);
   static uint8_t getStep(const CommandMessage* message);
   static ReturnValue_t getReturnCode(const CommandMessage* message);
   static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
   static void setCompletionReply(CommandMessage* message, ActionId_t fid, bool success,
-                                 ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+                                 ReturnValue_t result = returnvalue::OK);
 
   static void clear(CommandMessage* message);
 };

src/fsfw/action/CommandActionHelper.cpp

@@ -16,12 +16,12 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId
   uint8_t *storePointer;
   size_t maxSize = data->getSerializedSize();
   ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize, &storePointer);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t size = 0;
   result = data->serialize(&storePointer, &size, maxSize, SerializeIF::Endianness::BIG);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return sendCommand(receiver->getCommandQueue(), actionId, storeId);
@@ -35,7 +35,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId
   }
   store_address_t storeId;
   ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return sendCommand(receiver->getCommandQueue(), actionId, storeId);
@@ -46,7 +46,7 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI
   CommandMessage command;
   ActionMessage::setCommand(&command, actionId, storeId);
   ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ipcStore->deleteData(storeId);
   }
   lastTarget = queueId;
@@ -57,44 +57,44 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI
 ReturnValue_t CommandActionHelper::initialize() {
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   if (ipcStore == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
   queueToUse = owner->getCommandQueuePtr();
   if (queueToUse == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
   if (reply->getSender() != lastTarget) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   switch (reply->getCommand()) {
     case ActionMessage::COMPLETION_SUCCESS:
       commandCount--;
       owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     case ActionMessage::COMPLETION_FAILED:
       commandCount--;
       owner->completionFailedReceived(ActionMessage::getActionId(reply),
                                       ActionMessage::getReturnCode(reply));
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     case ActionMessage::STEP_SUCCESS:
       owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
                                     ActionMessage::getStep(reply));
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     case ActionMessage::STEP_FAILED:
       commandCount--;
       owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
                                 ActionMessage::getReturnCode(reply));
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     case ActionMessage::DATA_REPLY:
       extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     default:
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
   }
 }
 
@@ -104,7 +104,7 @@ void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address
   const uint8_t *data = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return;
   }
   owner->dataReceived(actionId, data, size);

src/fsfw/action/CommandActionHelper.h

@@ -4,7 +4,7 @@
 #include "ActionMessage.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serialize/SerializeIF.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 

src/fsfw/action/CommandsActionsIF.h

@@ -3,7 +3,7 @@
 
 #include "CommandActionHelper.h"
 #include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 
 /**
  * Interface to separate commanding actions of other objects.

src/fsfw/action/HasActionsIF.h

@@ -5,7 +5,7 @@
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
 #include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 
 /**
  * @brief
@@ -53,7 +53,7 @@ class HasActionsIF {
    *
    * @return
    * -@c EXECUTION_FINISHED Finish reply will be generated
-   * -@c Not RETURN_OK Step failure reply will be generated
+   * -@c Not returnvalue::OK Step failure reply will be generated
    */
   virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                       const uint8_t* data, size_t size) = 0;

src/fsfw/action/SimpleActionHelper.cpp

@@ -9,7 +9,7 @@ void SimpleActionHelper::step(ReturnValue_t result) {
   // STEP_OFFESET is subtracted to compensate for adding offset in base
   // method, which is not necessary here.
   ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction, result);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     resetHelper();
   }
 }
@@ -41,7 +41,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
   const uint8_t* dataPtr = nullptr;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
     return;
@@ -51,12 +51,12 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
   result = owner->executeAction(actionId, commandedBy, dataPtr, size);
   ipcStore->deleteData(dataAddress);
   switch (result) {
-    case HasReturnvaluesIF::RETURN_OK:
+    case returnvalue::OK:
       isExecuting = true;
       stepCount++;
       break;
     case HasActionsIF::EXECUTION_FINISHED:
-      ActionMessage::setCompletionReply(&reply, actionId, true, HasReturnvaluesIF::RETURN_OK);
+      ActionMessage::setCompletionReply(&reply, actionId, true, returnvalue::OK);
       queueToUse->sendMessage(commandedBy, &reply);
       break;
     default:

src/fsfw/action/SimpleActionHelper.h

@@ -12,8 +12,8 @@ class SimpleActionHelper : public ActionHelper {
  public:
   SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
   ~SimpleActionHelper() override;
-  void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-  void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+  void step(ReturnValue_t result = returnvalue::OK);
+  void finish(ReturnValue_t result = returnvalue::OK);
   ReturnValue_t reportData(SerializeIF* data);
 
  protected:

src/fsfw/cfdp/CfdpHandler.h

@@ -61,3 +61,4 @@
 //};
 //
 //#endif /* FSFW_CFDP_CFDPHANDLER_H_ */
+

src/fsfw/cfdp/FileSize.h

@@ -43,7 +43,7 @@ struct FileSize : public SerializeIF {
       uint32_t sizeTmp = 0;
       ReturnValue_t result =
           SerializeAdapter::deSerialize(&sizeTmp, buffer, size, streamEndianness);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
+      if (result == returnvalue::OK) {
         fileSize = sizeTmp;
       }
       return result;
@@ -53,11 +53,11 @@ struct FileSize : public SerializeIF {
   ReturnValue_t setFileSize(uint64_t fileSize, bool largeFile) {
     if (not largeFile and fileSize > UINT32_MAX) {
       // TODO: emit warning here
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     this->fileSize = fileSize;
     this->largeFile = largeFile;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   [[nodiscard]] bool isLargeFile() const { return largeFile; }

src/fsfw/cfdp/VarLenFields.cpp

@@ -5,7 +5,7 @@
 
 cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, size_t value) : VarLenField() {
   ReturnValue_t result = this->setValue(width, value);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
 #if FSFW_DISABLE_PRINTOUT == 0
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "cfdp::VarLenField: Setting value failed" << std::endl;
@@ -24,21 +24,21 @@ ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, size_
   switch (widthInBytes) {
     case (cfdp::WidthInBytes::ONE_BYTE): {
       if (value_ > UINT8_MAX) {
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return returnvalue::FAILED;
       }
       this->value.oneByte = value_;
       break;
     }
     case (cfdp::WidthInBytes::TWO_BYTES): {
       if (value_ > UINT16_MAX) {
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return returnvalue::FAILED;
       }
       this->value.twoBytes = value_;
       break;
     }
     case (cfdp::WidthInBytes::FOUR_BYTES): {
       if (value_ > UINT32_MAX) {
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return returnvalue::FAILED;
       }
       this->value.fourBytes = value_;
       break;
@@ -48,7 +48,7 @@ ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, size_
     }
   }
   this->width = widthInBytes;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 size_t cfdp::VarLenField::getValue() const {
@@ -76,7 +76,7 @@ ReturnValue_t cfdp::VarLenField::serialize(uint8_t **buffer, size_t *size, size_
       **buffer = value.oneByte;
       *size += 1;
       *buffer += 1;
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
     case (cfdp::WidthInBytes::TWO_BYTES): {
       return SerializeAdapter::serialize(&value.twoBytes, buffer, size, maxSize, streamEndianness);
@@ -85,7 +85,7 @@ ReturnValue_t cfdp::VarLenField::serialize(uint8_t **buffer, size_t *size, size_
       return SerializeAdapter::serialize(&value.fourBytes, buffer, size, maxSize, streamEndianness);
     }
     default: {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
   }
 }
@@ -104,7 +104,7 @@ ReturnValue_t cfdp::VarLenField::deSerialize(const uint8_t **buffer, size_t *siz
     case (cfdp::WidthInBytes::ONE_BYTE): {
       value.oneByte = **buffer;
       *size += 1;
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
     case (cfdp::WidthInBytes::TWO_BYTES): {
       return SerializeAdapter::deSerialize(&value.twoBytes, buffer, size, streamEndianness);
@@ -113,7 +113,7 @@ ReturnValue_t cfdp::VarLenField::deSerialize(const uint8_t **buffer, size_t *siz
       return SerializeAdapter::deSerialize(&value.fourBytes, buffer, size, streamEndianness);
     }
     default: {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
   }
 }

src/fsfw/cfdp/definitions.h

@@ -7,7 +7,7 @@
 #include <cstdint>
 
 #include "fsfw/returnvalues/FwClassIds.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 
 namespace cfdp {
 
@@ -19,21 +19,24 @@ static constexpr uint8_t VERSION_BITS = CFDP_VERSION_2 << 5;
 
 static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP;
 
-static constexpr ReturnValue_t INVALID_TLV_TYPE = result::makeCode(CFDP_CLASS_ID, 1);
-static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS = result::makeCode(CFDP_CLASS_ID, 2);
-static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN = result::makeCode(CFDP_CLASS_ID, 3);
-static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS = result::makeCode(CFDP_CLASS_ID, 4);
+static constexpr ReturnValue_t INVALID_TLV_TYPE = returnvalue::makeCode(CFDP_CLASS_ID, 1);
+static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS = returnvalue::makeCode(CFDP_CLASS_ID, 2);
+static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN = returnvalue::makeCode(CFDP_CLASS_ID, 3);
+static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS =
+    returnvalue::makeCode(CFDP_CLASS_ID, 4);
 //! Can not parse options. This can also occur because there are options
 //! available but the user did not pass a valid options array
-static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS = result::makeCode(CFDP_CLASS_ID, 5);
-static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS = result::makeCode(CFDP_CLASS_ID, 6);
+static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS =
+    returnvalue::makeCode(CFDP_CLASS_ID, 5);
+static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS = returnvalue::makeCode(CFDP_CLASS_ID, 6);
 static constexpr ReturnValue_t FINISHED_CANT_PARSE_FS_RESPONSES =
-    result::makeCode(CFDP_CLASS_ID, 6);
-static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE = result::makeCode(CFDP_CLASS_ID, 8);
+    returnvalue::makeCode(CFDP_CLASS_ID, 6);
+static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE =
+    returnvalue::makeCode(CFDP_CLASS_ID, 8);
 //! Can not parse filestore response because user did not pass a valid instance
 //! or remaining size is invalid
 static constexpr ReturnValue_t FILESTORE_RESPONSE_CANT_PARSE_FS_MESSAGE =
-    result::makeCode(CFDP_CLASS_ID, 9);
+    returnvalue::makeCode(CFDP_CLASS_ID, 9);
 
 //! Checksum types according to the SANA Checksum Types registry
 //! https://sanaregistry.org/r/checksum_identifiers/

src/fsfw/cfdp/pdu/AckPduDeserializer.cpp

@@ -5,8 +5,7 @@ AckPduDeserializer::AckPduDeserializer(const uint8_t* pduBuf, size_t maxSize, Ac
 
 ReturnValue_t AckPduDeserializer::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
+  if (result != returnvalue::OK) {
   }
   size_t currentIdx = FileDirectiveReader::getHeaderSize();
   if (currentIdx + 2 > this->maxSize) {
@@ -15,7 +14,7 @@ ReturnValue_t AckPduDeserializer::parseData() {
   if (not checkAndSetCodes(pointers.rawPtr[currentIdx], pointers.rawPtr[currentIdx + 1])) {
     return cfdp::INVALID_ACK_DIRECTIVE_FIELDS;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 bool AckPduDeserializer::checkAndSetCodes(uint8_t firstByte, uint8_t secondByte) {

src/fsfw/cfdp/pdu/AckPduSerializer.cpp

@@ -10,7 +10,7 @@ size_t AckPduSerializer::getSerializedSize() const {
 ReturnValue_t AckPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                           Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   cfdp::FileDirectives ackedDirective = ackInfo.getAckedDirective();
@@ -20,7 +20,7 @@ ReturnValue_t AckPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
   if (ackedDirective != cfdp::FileDirectives::FINISH and
       ackedDirective != cfdp::FileDirectives::EOF_DIRECTIVE) {
     // TODO: better returncode
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (*size + 2 > maxSize) {
     return SerializeIF::BUFFER_TOO_SHORT;
@@ -31,5 +31,5 @@ ReturnValue_t AckPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
   **buffer = ackedConditionCode << 4 | transactionStatus;
   *buffer += 1;
   *size += 1;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

src/fsfw/cfdp/pdu/EofPduDeserializer.cpp

@@ -8,7 +8,7 @@ EofPduDeserializer::EofPduDeserializer(const uint8_t* pduBuf, size_t maxSize, Eo
 
 ReturnValue_t EofPduDeserializer::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -31,7 +31,7 @@ ReturnValue_t EofPduDeserializer::parseData() {
   uint32_t checksum = 0;
   auto endianness = getEndianness();
   result = SerializeAdapter::deSerialize(&checksum, &bufPtr, &deserLen, endianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   info.setChecksum(checksum);
@@ -44,7 +44,7 @@ ReturnValue_t EofPduDeserializer::parseData() {
     result = SerializeAdapter::deSerialize(&fileSizeValue, &bufPtr, &deserLen, endianness);
     info.setFileSize(fileSizeValue, false);
   }
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (info.getConditionCode() != cfdp::ConditionCode::NO_ERROR) {
@@ -61,7 +61,7 @@ ReturnValue_t EofPduDeserializer::parseData() {
           " given TLV pointer invalid");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     result = tlvPtr->deSerialize(&bufPtr, &deserLen, endianness);
   }

src/fsfw/cfdp/pdu/EofPduSerializer.cpp

@@ -15,7 +15,7 @@ size_t EofPduSerializer::getSerializedSize() const {
 ReturnValue_t EofPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                           Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (*size + 1 > maxSize) {
@@ -26,7 +26,7 @@ ReturnValue_t EofPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
   *size += 1;
   uint32_t checksum = info.getChecksum();
   result = SerializeAdapter::serialize(&checksum, buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (info.getFileSize().isLargeFile()) {

src/fsfw/cfdp/pdu/FileDataCreator.cpp

@@ -16,7 +16,7 @@ void FileDataCreator::update() {
 ReturnValue_t FileDataCreator::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                          Endianness streamEndianness) const {
   ReturnValue_t result = HeaderCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (*size + this->getSerializedSize() > maxSize) {
@@ -35,7 +35,7 @@ ReturnValue_t FileDataCreator::serialize(uint8_t** buffer, size_t* size, size_t
   }
   cfdp::FileSize& offset = info.getOffset();
   result = offset.serialize(this->getLargeFileFlag(), buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t fileSize = 0;
@@ -46,7 +46,7 @@ ReturnValue_t FileDataCreator::serialize(uint8_t** buffer, size_t* size, size_t
   std::memcpy(*buffer, readOnlyPtr, fileSize);
   *buffer += fileSize;
   *size += fileSize;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 size_t FileDataCreator::getSerializedSize() const {

src/fsfw/cfdp/pdu/FileDataInfo.cpp

@@ -50,11 +50,11 @@ ReturnValue_t FileDataInfo::addSegmentMetadataInfo(cfdp::RecordContinuationState
   this->segmentMetadataFlag = cfdp::SegmentMetadataFlag::PRESENT;
   this->recContState = recContState;
   if (segmentMetadataLen > 63) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   this->segmentMetadata = segmentMetadata;
   this->segmentMetadataLen = segmentMetadataLen;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 const uint8_t *FileDataInfo::getFileData(size_t *fileSize) const {

src/fsfw/cfdp/pdu/FileDataReader.cpp

@@ -5,7 +5,7 @@ FileDataReader::FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataIn
 
 ReturnValue_t FileDataReader::parseData() {
   ReturnValue_t result = HeaderReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t currentIdx = HeaderReader::getHeaderSize();
@@ -31,13 +31,13 @@ ReturnValue_t FileDataReader::parseData() {
     }
   }
   result = info.getOffset().deSerialize(&buf, &remSize, this->getEndianness());
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (remSize > 0) {
     info.setFileData(buf, remSize);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 SerializeIF::Endianness FileDataReader::getEndianness() const { return endianness; }

src/fsfw/cfdp/pdu/FinishedInfo.cpp

@@ -45,14 +45,14 @@ ReturnValue_t FinishedInfo::setFilestoreResponsesArray(FilestoreResponseTlv** fs
   if (maxFsResponsesLen != nullptr) {
     this->fsResponsesMaxLen = *maxFsResponsesLen;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t FinishedInfo::getFilestoreResonses(FilestoreResponseTlv*** fsResponses,
                                                  size_t* fsResponsesLen,
                                                  size_t* fsResponsesMaxLen) {
   if (fsResponses == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   *fsResponses = this->fsResponses;
   if (fsResponsesLen != nullptr) {
@@ -61,7 +61,7 @@ ReturnValue_t FinishedInfo::getFilestoreResonses(FilestoreResponseTlv*** fsRespo
   if (fsResponsesMaxLen != nullptr) {
     *fsResponsesMaxLen = this->fsResponsesMaxLen;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 void FinishedInfo::setFaultLocation(EntityIdTlv* faultLocation) {
@@ -70,10 +70,10 @@ void FinishedInfo::setFaultLocation(EntityIdTlv* faultLocation) {
 
 ReturnValue_t FinishedInfo::getFaultLocation(EntityIdTlv** faultLocation) {
   if (this->faultLocation == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   *faultLocation = this->faultLocation;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 cfdp::ConditionCode FinishedInfo::getConditionCode() const { return conditionCode; }

src/fsfw/cfdp/pdu/FinishedPduDeserializer.cpp

@@ -6,7 +6,7 @@ FinishPduDeserializer::FinishPduDeserializer(const uint8_t* pduBuf, size_t maxSi
 
 ReturnValue_t FinishPduDeserializer::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t currentIdx = FileDirectiveReader::getHeaderSize();
@@ -33,7 +33,7 @@ FinishedInfo& FinishPduDeserializer::getInfo() { return finishedInfo; }
 
 ReturnValue_t FinishPduDeserializer::parseTlvs(size_t remLen, size_t currentIdx, const uint8_t* buf,
                                                cfdp::ConditionCode conditionCode) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   size_t fsResponsesIdx = 0;
   auto endianness = getEndianness();
   FilestoreResponseTlv** fsResponseArray = nullptr;
@@ -60,7 +60,7 @@ ReturnValue_t FinishPduDeserializer::parseTlvs(size_t remLen, size_t currentIdx,
         return cfdp::FINISHED_CANT_PARSE_FS_RESPONSES;
       }
       result = fsResponseArray[fsResponsesIdx]->deSerialize(&buf, &remLen, endianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
       fsResponsesIdx += 1;
@@ -72,11 +72,11 @@ ReturnValue_t FinishPduDeserializer::parseTlvs(size_t remLen, size_t currentIdx,
         return cfdp::INVALID_TLV_TYPE;
       }
       result = finishedInfo.getFaultLocation(&faultLocation);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
       result = faultLocation->deSerialize(&buf, &remLen, endianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
     } else {

src/fsfw/cfdp/pdu/FinishedPduSerializer.cpp

@@ -16,7 +16,7 @@ void FinishPduSerializer::updateDirectiveFieldLen() {
 ReturnValue_t FinishPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                              Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (*size + 1 >= maxSize) {
@@ -33,13 +33,13 @@ ReturnValue_t FinishPduSerializer::serialize(uint8_t **buffer, size_t *size, siz
     finishInfo.getFilestoreResonses(&fsResponsesArray, &fsResponsesArrayLen, nullptr);
     for (size_t idx = 0; idx < fsResponsesArrayLen; idx++) {
       result = fsResponsesArray[idx]->serialize(buffer, size, maxSize, streamEndianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
     }
   }
   EntityIdTlv *entityId = nullptr;
-  if (finishInfo.getFaultLocation(&entityId) == HasReturnvaluesIF::RETURN_OK) {
+  if (finishInfo.getFaultLocation(&entityId) == returnvalue::OK) {
     result = entityId->serialize(buffer, size, maxSize, streamEndianness);
   }
   return result;

src/fsfw/cfdp/pdu/HeaderReader.h

@@ -37,8 +37,8 @@ class HeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
   /**
    * This needs to be called before accessing the PDU fields to avoid segmentation faults.
    * @return
-   *  - RETURN_OK on parse success
-   *  - RETURN_FAILED Invalid raw data
+   *  - returnvalue::OK on parse success
+   *  - returnvalue::FAILED Invalid raw data
    *  - SerializeIF::BUFFER_TOO_SHORT if buffer is shorter than expected
    */
   virtual ReturnValue_t parseData();
@@ -65,7 +65,7 @@ class HeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
   void getDestId(cfdp::EntityId& destId) const override;
   void getTransactionSeqNum(cfdp::TransactionSeqNum& seqNum) const override;
 
-  ReturnValue_t deserResult = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t deserResult = returnvalue::OK;
 
   [[nodiscard]] size_t getMaxSize() const;
 

src/fsfw/cfdp/pdu/KeepAlivePduDeserializer.cpp

@@ -6,7 +6,7 @@ KeepAlivePduDeserializer::KeepAlivePduDeserializer(const uint8_t* pduBuf, size_t
 
 ReturnValue_t KeepAlivePduDeserializer::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t currentIdx = FileDirectiveReader::getHeaderSize();

src/fsfw/cfdp/pdu/KeepAlivePduSerializer.cpp

@@ -18,7 +18,7 @@ void KeepAlivePduSerializer::updateDirectiveFieldLen() {
 ReturnValue_t KeepAlivePduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                                 Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return progress.serialize(this->getLargeFileFlag(), buffer, size, maxSize, streamEndianness);

src/fsfw/cfdp/pdu/MetadataInfo.cpp

@@ -39,7 +39,7 @@ cfdp::FileSize& MetadataInfo::getFileSize() { return fileSize; }
 ReturnValue_t MetadataInfo::getOptions(cfdp::Tlv*** optionsArray_, size_t* optionsLen_,
                                        size_t* maxOptsLen) {
   if (optionsArray_ == nullptr or optionsArray == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   *optionsArray_ = optionsArray;
   if (optionsLen_ != nullptr) {
@@ -48,7 +48,7 @@ ReturnValue_t MetadataInfo::getOptions(cfdp::Tlv*** optionsArray_, size_t* optio
   if (maxOptsLen != nullptr) {
     *maxOptsLen = this->maxOptionsLen;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 bool MetadataInfo::hasOptions() const {

src/fsfw/cfdp/pdu/MetadataPduCreator.cpp

@@ -16,7 +16,7 @@ size_t MetadataPduCreator::getSerializedSize() const {
 ReturnValue_t MetadataPduCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                             Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (*size + 1 >= maxSize) {
@@ -26,15 +26,15 @@ ReturnValue_t MetadataPduCreator::serialize(uint8_t **buffer, size_t *size, size
   *buffer += 1;
   *size += 1;
   result = info.getFileSize().serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = info.getSourceFileName().serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = info.getDestFileName().serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -44,7 +44,7 @@ ReturnValue_t MetadataPduCreator::serialize(uint8_t **buffer, size_t *size, size
     info.getOptions(&optsArray, &optsLen, nullptr);
     for (size_t idx = 0; idx < optsLen; idx++) {
       result = optsArray[idx]->serialize(buffer, size, maxSize, streamEndianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
     }

src/fsfw/cfdp/pdu/MetadataPduReader.cpp

@@ -5,7 +5,7 @@ MetadataPduReader::MetadataPduReader(const uint8_t* pduBuf, size_t maxSize, Meta
 
 ReturnValue_t MetadataPduReader::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t currentIdx = FileDirectiveReader::getHeaderSize();
@@ -20,15 +20,15 @@ ReturnValue_t MetadataPduReader::parseData() {
   buf += 1;
   auto endianness = getEndianness();
   result = info.getFileSize().deSerialize(&buf, &remSize, endianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = info.getSourceFileName().deSerialize(&buf, &remSize, endianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = info.getDestFileName().deSerialize(&buf, &remSize, endianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -46,7 +46,7 @@ ReturnValue_t MetadataPduReader::parseData() {
         return cfdp::METADATA_CANT_PARSE_OPTIONS;
       }
       result = optionsArray[optsIdx]->deSerialize(&buf, &remSize, endianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
       optsIdx++;

src/fsfw/cfdp/pdu/NakPduDeserializer.cpp

@@ -5,7 +5,7 @@ NakPduDeserializer::NakPduDeserializer(const uint8_t* pduBuf, size_t maxSize, Na
 
 ReturnValue_t NakPduDeserializer::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t currentIdx = FileDirectiveReader::getHeaderSize();
@@ -16,11 +16,11 @@ ReturnValue_t NakPduDeserializer::parseData() {
   }
   result =
       nakInfo.getStartOfScope().deSerialize(&buffer, &remSize, SerializeIF::Endianness::NETWORK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = nakInfo.getEndOfScope().deSerialize(&buffer, &remSize, SerializeIF::Endianness::NETWORK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   nakInfo.setSegmentRequestLen(0);
@@ -39,12 +39,12 @@ ReturnValue_t NakPduDeserializer::parseData() {
         }
         result =
             segReqs[idx].first.deSerialize(&buffer, &remSize, SerializeIF::Endianness::NETWORK);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
+        if (result != returnvalue::OK) {
           return result;
         }
         result =
             segReqs[idx].second.deSerialize(&buffer, &remSize, SerializeIF::Endianness::NETWORK);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
+        if (result != returnvalue::OK) {
           return result;
         }
         idx++;

src/fsfw/cfdp/pdu/NakPduSerializer.cpp

@@ -16,15 +16,15 @@ size_t NakPduSerializer::getSerializedSize() const {
 ReturnValue_t NakPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                           Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = nakInfo.getStartOfScope().serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = nakInfo.getEndOfScope().serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (nakInfo.hasSegmentRequests()) {
@@ -33,11 +33,11 @@ ReturnValue_t NakPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
     nakInfo.getSegmentRequests(&segmentRequests, &segmentRequestLen, nullptr);
     for (size_t idx = 0; idx < segmentRequestLen; idx++) {
       result = segmentRequests[idx].first.serialize(buffer, size, maxSize, streamEndianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
       result = segmentRequests[idx].second.serialize(buffer, size, maxSize, streamEndianness);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         return result;
       }
     }

src/fsfw/cfdp/pdu/PromptPduDeserializer.cpp

@@ -9,7 +9,7 @@ cfdp::PromptResponseRequired PromptPduDeserializer::getPromptResponseRequired()
 
 ReturnValue_t PromptPduDeserializer::parseData() {
   ReturnValue_t result = FileDirectiveReader::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (FileDirectiveReader::getWholePduSize() <= FileDirectiveReader::getHeaderSize()) {
@@ -17,5 +17,5 @@ ReturnValue_t PromptPduDeserializer::parseData() {
   }
   responseRequired = static_cast<cfdp::PromptResponseRequired>(
       (pointers.rawPtr[FileDirectiveReader::getHeaderSize()] >> 7) & 0x01);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

src/fsfw/cfdp/pdu/PromptPduSerializer.cpp

@@ -12,7 +12,7 @@ size_t PromptPduSerializer::getSerializedSize() const {
 ReturnValue_t PromptPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                              Endianness streamEndianness) const {
   ReturnValue_t result = FileDirectiveCreator::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (*size + 1 > maxSize) {

src/fsfw/cfdp/tlv/FaultHandlerOverrideTlv.cpp

@@ -22,7 +22,7 @@ ReturnValue_t FaultHandlerOverrideTlv::serialize(uint8_t **buffer, size_t *size,
   **buffer = this->conditionCode << 4 | this->handlerCode;
   *buffer += 1;
   *size += 1;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 size_t FaultHandlerOverrideTlv::getSerializedSize() const { return getLengthField() + 2; }
@@ -40,7 +40,7 @@ ReturnValue_t FaultHandlerOverrideTlv::deSerialize(const uint8_t **buffer, size_
   *size -= 1;
   size_t detectedSize = **buffer;
   if (detectedSize != getLengthField()) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   *buffer += 1;
   *size += 1;
@@ -48,7 +48,7 @@ ReturnValue_t FaultHandlerOverrideTlv::deSerialize(const uint8_t **buffer, size_
   this->handlerCode = static_cast<cfdp::FaultHandlerCodes>(**buffer & 0x0f);
   *buffer += 1;
   *size += 1;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 cfdp::TlvTypes FaultHandlerOverrideTlv::getType() const { return cfdp::TlvTypes::FAULT_HANDLER; }

src/fsfw/cfdp/tlv/FilestoreRequestTlv.cpp

@@ -16,11 +16,11 @@ void FilestoreRequestTlv::setSecondFileName(cfdp::Lv *secondFileName) {
 ReturnValue_t FilestoreRequestTlv::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                              Endianness streamEndianness) const {
   ReturnValue_t result = commonSerialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = firstFileName.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (requiresSecondFileName()) {
@@ -30,13 +30,13 @@ ReturnValue_t FilestoreRequestTlv::serialize(uint8_t **buffer, size_t *size, siz
     }
     secondFileName->serialize(buffer, size, maxSize, streamEndianness);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t FilestoreRequestTlv::deSerialize(const uint8_t **buffer, size_t *size,
                                                Endianness streamEndianness) {
   ReturnValue_t result = commonDeserialize(buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return deSerializeFromValue(buffer, size, streamEndianness);
@@ -63,13 +63,13 @@ ReturnValue_t FilestoreRequestTlv::deSerializeFromValue(const uint8_t **buffer,
   *buffer += 1;
   *size -= 1;
   ReturnValue_t result = firstFileName.deSerialize(buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (requiresSecondFileName()) {
     if (secondFileName == nullptr) {
       secondFileNameMissing();
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     result = secondFileName->deSerialize(buffer, size, streamEndianness);
   }

src/fsfw/cfdp/tlv/FilestoreResponseTlv.cpp

@@ -32,11 +32,11 @@ ReturnValue_t FilestoreResponseTlv::serialize(uint8_t **buffer, size_t *size, si
                                               Endianness streamEndianness) const {
   ReturnValue_t result =
       commonSerialize(buffer, size, maxSize, streamEndianness, true, this->statusCode);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = firstFileName.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (requiresSecondFileName()) {
@@ -61,7 +61,7 @@ ReturnValue_t FilestoreResponseTlv::serialize(uint8_t **buffer, size_t *size, si
 ReturnValue_t FilestoreResponseTlv::deSerialize(const uint8_t **buffer, size_t *size,
                                                 Endianness streamEndianness) {
   ReturnValue_t result = commonDeserialize(buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return deSerializeFromValue(buffer, size, streamEndianness);
@@ -75,7 +75,7 @@ ReturnValue_t FilestoreResponseTlv::deSerializeFromValue(const uint8_t **buffer,
   *buffer += 1;
   *size -= 1;
   ReturnValue_t result = firstFileName.deSerialize(buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   if (requiresSecondFileName()) {
@@ -83,7 +83,7 @@ ReturnValue_t FilestoreResponseTlv::deSerializeFromValue(const uint8_t **buffer,
       return cfdp::FILESTORE_REQUIRES_SECOND_FILE;
     }
     result = secondFileName->deSerialize(buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -98,7 +98,7 @@ ReturnValue_t FilestoreResponseTlv::deSerializeFromValue(const uint8_t **buffer,
     *size -= 1;
     *buffer += 1;
     // Ignore empty filestore message
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
   return filestoreMsg->deSerialize(buffer, size, streamEndianness);
 }

src/fsfw/cfdp/tlv/FilestoreTlvBase.h

@@ -74,7 +74,7 @@ class FilestoreTlvBase : public TlvIF {
                                 Endianness streamEndianness, bool isResponse = false,
                                 uint8_t responseStatusCode = 0) const {
     if (buffer == nullptr or size == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     if (maxSize < 3) {
       return SerializeIF::BUFFER_TOO_SHORT;
@@ -91,13 +91,13 @@ class FilestoreTlvBase : public TlvIF {
     }
     *buffer += 1;
     *size += 1;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   ReturnValue_t commonDeserialize(const uint8_t** buffer, size_t* size,
                                   SerializeIF::Endianness streamEndianness) {
     if (buffer == nullptr or size == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     if (*size < 3) {
       return SerializeIF::STREAM_TOO_SHORT;
@@ -115,7 +115,7 @@ class FilestoreTlvBase : public TlvIF {
     if (remainingLength == 0) {
       return SerializeIF::STREAM_TOO_SHORT;
     }
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   [[nodiscard]] bool requiresSecondFileName() const {
@@ -153,7 +153,7 @@ class FilestoreTlvBase : public TlvIF {
     size_t serSize = 0;
     uint8_t* valueStart = buffer + 2;
     ReturnValue_t result = this->serialize(&buffer, &serSize, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     tlv.setValue(valueStart, serSize - 2);

src/fsfw/cfdp/tlv/Lv.cpp

@@ -37,13 +37,13 @@ ReturnValue_t cfdp::Lv::serialize(uint8_t** buffer, size_t* size, size_t maxSize
     return BUFFER_TOO_SHORT;
   }
   if (buffer == nullptr or size == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (zeroLen) {
     **buffer = 0;
     *size += 1;
     *buffer += 1;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
   return value.serialize(buffer, size, maxSize, streamEndianness);
 }
@@ -60,7 +60,7 @@ size_t cfdp::Lv::getSerializedSize() const {
 ReturnValue_t cfdp::Lv::deSerialize(const uint8_t** buffer, size_t* size,
                                     Endianness streamEndianness) {
   if (buffer == nullptr or size == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (*size < 1) {
     return SerializeIF::STREAM_TOO_SHORT;
@@ -70,7 +70,7 @@ ReturnValue_t cfdp::Lv::deSerialize(const uint8_t** buffer, size_t* size,
     zeroLen = true;
     *buffer += 1;
     *size -= 1;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   } else if (*size < lengthField + 1) {
     return SerializeIF::STREAM_TOO_SHORT;
   }
@@ -79,7 +79,7 @@ ReturnValue_t cfdp::Lv::deSerialize(const uint8_t** buffer, size_t* size,
   value.setBuffer(const_cast<uint8_t*>(*buffer + 1), lengthField);
   *buffer += 1 + lengthField;
   *size -= 1 + lengthField;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 const uint8_t* cfdp::Lv::getValue(size_t* size) const {

src/fsfw/cfdp/tlv/Tlv.cpp

@@ -12,7 +12,7 @@ cfdp::Tlv::Tlv() : value(static_cast<uint8_t *>(nullptr), 0, true) {}
 ReturnValue_t cfdp::Tlv::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                    Endianness streamEndianness) const {
   if (buffer == nullptr or size == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (*size + 2 > maxSize) {
     return BUFFER_TOO_SHORT;
@@ -28,10 +28,10 @@ ReturnValue_t cfdp::Tlv::serialize(uint8_t **buffer, size_t *size, size_t maxSiz
     **buffer = 0;
     *size += 1;
     *buffer += 1;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
   if (value.getConstBuffer() == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   return value.serialize(buffer, size, maxSize, streamEndianness);
 }
@@ -48,7 +48,7 @@ size_t cfdp::Tlv::getSerializedSize() const {
 ReturnValue_t cfdp::Tlv::deSerialize(const uint8_t **buffer, size_t *size,
                                      Endianness streamEndianness) {
   if (buffer == nullptr or size == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (*size < 2) {
     return STREAM_TOO_SHORT;
@@ -68,7 +68,7 @@ ReturnValue_t cfdp::Tlv::deSerialize(const uint8_t **buffer, size_t *size,
     zeroLen = true;
     *buffer += 1;
     *size -= 1;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
   if (lengthField + 1 > *size) {
     return SerializeIF::STREAM_TOO_SHORT;
@@ -78,7 +78,7 @@ ReturnValue_t cfdp::Tlv::deSerialize(const uint8_t **buffer, size_t *size,
   value.setBuffer(const_cast<uint8_t *>(*buffer + 1), lengthField);
   *buffer += 1 + lengthField;
   *size -= 1 + lengthField;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 const uint8_t *cfdp::Tlv::getValue() const { return value.getConstBuffer(); }

src/fsfw/cfdp/tlv/Tlv.h

@@ -23,7 +23,7 @@ class Tlv : public TlvIF {
    * @param maxSize
    * @param streamEndianness
    * @return
-   *  - RETURN_OK on success
+   *  - returnvalue::OK on success
    *  - INVALID_TLV_TYPE
    *  - SerializeIF returncode on wrong serialization parameters
    */
@@ -37,7 +37,7 @@ class Tlv : public TlvIF {
    * @param buffer Raw buffer including the size field
    * @param size
    * @param streamEndianness
-   *  - RETURN_OK on success
+   *  - returnvalue::OK on success
    *  - INVALID_TLV_TYPE
    *  - SerializeIF returncode on wrong deserialization parameters
    */

src/fsfw/container/ArrayList.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_CONTAINER_ARRAYLIST_H_
 #define FSFW_CONTAINER_ARRAYLIST_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serialize/SerializeIF.h"
 
@@ -183,7 +183,7 @@ class ArrayList {
    * @param entry
    * @return
    *          -@c FULL if the List is full
-   *          -@c RETURN_OK else
+   *          -@c returnvalue::OK else
    */
   ReturnValue_t insert(T entry) {
     if (size >= maxSize_) {
@@ -191,7 +191,7 @@ class ArrayList {
     }
     entries[size] = entry;
     ++size;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   /**

src/fsfw/container/FIFOBase.h

@@ -4,7 +4,7 @@
 #include <cstddef>
 #include <cstring>
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 
 template <typename T>
 class FIFOBase {
@@ -20,24 +20,24 @@ class FIFOBase {
   /**
    * Insert value into FIFO
    * @param value
-   * @return RETURN_OK on success, FULL if full
+   * @return returnvalue::OK on success, FULL if full
    */
   ReturnValue_t insert(T value);
   /**
    * Retrieve item from FIFO. This removes the item from the FIFO.
    * @param value Must point to a valid T
-   * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+   * @return returnvalue::OK on success, EMPTY if empty and FAILED if nullptr check failed
    */
   ReturnValue_t retrieve(T* value);
   /**
    * Retrieve item from FIFO without removing it from FIFO.
    * @param value Must point to a valid T
-   * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+   * @return returnvalue::OK on success, EMPTY if empty and FAILED if nullptr check failed
    */
   ReturnValue_t peek(T* value);
   /**
    * Remove item from FIFO.
-   * @return RETURN_OK on success, EMPTY if empty
+   * @return returnvalue::OK on success, EMPTY if empty
    */
   ReturnValue_t pop();
 

src/fsfw/container/FIFOBase.tpp

@@ -17,7 +17,7 @@ inline ReturnValue_t FIFOBase<T>::insert(T value) {
     values[writeIndex] = value;
     writeIndex = next(writeIndex);
     ++currentSize;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 };
 
@@ -27,12 +27,12 @@ inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
     return EMPTY;
   } else {
     if (value == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     *value = values[readIndex];
     readIndex = next(readIndex);
     --currentSize;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 };
 
@@ -42,10 +42,10 @@ inline ReturnValue_t FIFOBase<T>::peek(T* value) {
     return EMPTY;
   } else {
     if (value == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     *value = values[readIndex];
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 };
 

src/fsfw/container/FixedMap.h

@@ -4,7 +4,7 @@
 #include <type_traits>
 #include <utility>
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 #include "ArrayList.h"
 
 /**
@@ -75,7 +75,7 @@ class FixedMap : public SerializeIF {
   uint32_t size() const { return _size; }
 
   ReturnValue_t insert(key_t key, T value, Iterator* storedValue = nullptr) {
-    if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+    if (exists(key) == returnvalue::OK) {
       return KEY_ALREADY_EXISTS;
     }
     if (_size == theMap.maxSize()) {
@@ -87,7 +87,7 @@ class FixedMap : public SerializeIF {
       *storedValue = Iterator(&theMap[_size]);
     }
     ++_size;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   ReturnValue_t insert(std::pair<key_t, T> pair) { return insert(pair.first, pair.second); }
@@ -95,7 +95,7 @@ class FixedMap : public SerializeIF {
   ReturnValue_t exists(key_t key) const {
     ReturnValue_t result = KEY_DOES_NOT_EXIST;
     if (findIndex(key) < _size) {
-      result = HasReturnvaluesIF::RETURN_OK;
+      result = returnvalue::OK;
     }
     return result;
   }
@@ -108,7 +108,7 @@ class FixedMap : public SerializeIF {
     theMap[i] = theMap[_size - 1];
     --_size;
     --((*iter).value);
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   ReturnValue_t erase(key_t key) {
@@ -118,14 +118,14 @@ class FixedMap : public SerializeIF {
     }
     theMap[i] = theMap[_size - 1];
     --_size;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   T* findValue(key_t key) const { return &theMap[findIndex(key)].second; }
 
   Iterator find(key_t key) const {
     ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return end();
     }
     return Iterator(&theMap[findIndex(key)]);
@@ -133,11 +133,11 @@ class FixedMap : public SerializeIF {
 
   ReturnValue_t find(key_t key, T** value) const {
     ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     *value = &theMap[findIndex(key)].second;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   bool empty() {
@@ -165,7 +165,7 @@ class FixedMap : public SerializeIF {
     ReturnValue_t result =
         SerializeAdapter::serialize(&this->_size, buffer, size, maxSize, streamEndianness);
     uint32_t i = 0;
-    while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+    while ((result == returnvalue::OK) && (i < this->_size)) {
       result =
           SerializeAdapter::serialize(&theMap[i].first, buffer, size, maxSize, streamEndianness);
       result =
@@ -195,7 +195,7 @@ class FixedMap : public SerializeIF {
       return SerializeIF::TOO_MANY_ELEMENTS;
     }
     uint32_t i = 0;
-    while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+    while ((result == returnvalue::OK) && (i < this->_size)) {
       result = SerializeAdapter::deSerialize(&theMap[i].first, buffer, size, streamEndianness);
       result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size, streamEndianness);
       ++i;

src/fsfw/container/FixedOrderedMultimap.h

@@ -100,7 +100,7 @@ class FixedOrderedMultimap {
    * @param[in] value Value of the new element
    * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a
    * nullptr
-   * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+   * @return returnvalue::OK if insert was successful, MAP_FULL if no space is available
    */
   ReturnValue_t insert(key_t key, T value, Iterator* storedValue = nullptr);
 
@@ -108,14 +108,14 @@ class FixedOrderedMultimap {
    * Used to insert new pair instead of single values
    *
    * @param pair Pair to be inserted
-   * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+   * @return returnvalue::OK if insert was successful, MAP_FULL if no space is available
    */
   ReturnValue_t insert(std::pair<key_t, T> pair);
 
   /***
    * Can be used to check if a certain key is in the map
    * @param key Key to be checked
-   * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+   * @return returnvalue::OK if the key exists KEY_DOES_NOT_EXIST otherwise
    */
   ReturnValue_t exists(key_t key) const;
 
@@ -127,14 +127,14 @@ class FixedOrderedMultimap {
    *
    * @warning The iterator needs to be valid and dereferenceable
    * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
-   * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+   * @return returnvalue::OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
    */
   ReturnValue_t erase(Iterator* iter);
 
   /***
    * Used to erase by key
    * @param key Key to be erased
-   * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+   * @return returnvalue::OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
    */
   ReturnValue_t erase(key_t key);
 
@@ -148,7 +148,7 @@ class FixedOrderedMultimap {
    */
   Iterator find(key_t key) const {
     ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return end();
     }
     return Iterator(&theMap[findFirstIndex(key)]);
@@ -160,7 +160,7 @@ class FixedOrderedMultimap {
    *
    * @param key Key to search for
    * @param value Found value
-   * @return RETURN_OK if it points to the value,
+   * @return returnvalue::OK if it points to the value,
    * KEY_DOES_NOT_EXIST if the key is not in the map
    */
   ReturnValue_t find(key_t key, T** value) const;

src/fsfw/container/FixedOrderedMultimap.tpp

@@ -16,7 +16,7 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t k
   if (storedValue != nullptr) {
     *storedValue = Iterator(&theMap[position]);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
@@ -27,7 +27,7 @@ template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
   ReturnValue_t result = KEY_DOES_NOT_EXIST;
   if (findFirstIndex(key) < _size) {
-    result = HasReturnvaluesIF::RETURN_OK;
+    result = returnvalue::OK;
   }
   return result;
 }
@@ -44,7 +44,7 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator
   } else {
     *iter = begin();
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename key_t, typename T, typename KEY_COMPARE>
@@ -57,17 +57,17 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t ke
     removeFromPosition(i);
     i = findFirstIndex(key, i);
   } while (i < _size);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
   ReturnValue_t result = exists(key);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   *value = &theMap[findFirstIndex(key)].second;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename key_t, typename T, typename KEY_COMPARE>

src/fsfw/container/IndexedRingMemoryArray.h

@@ -4,7 +4,7 @@
 #include <cmath>
 
 #include "../globalfunctions/CRC.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "ArrayList.h"
@@ -52,15 +52,15 @@ class Index : public SerializeIF {
                           Endianness streamEndianness) const {
     ReturnValue_t result =
         SerializeAdapter::serialize(&blockStartAddress, buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result = indexType.serialize(buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result = SerializeAdapter::serialize(&this->size, buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result =
@@ -71,19 +71,19 @@ class Index : public SerializeIF {
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
     ReturnValue_t result =
         SerializeAdapter::deSerialize(&blockStartAddress, buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result = indexType.deSerialize(buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result = SerializeAdapter::deSerialize(&this->size, buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result = SerializeAdapter::deSerialize(&this->storedPackets, buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     return result;
@@ -449,13 +449,13 @@ class IndexedRingMemoryArray : public SerializeIF, public ArrayList<Index<T>, ui
     // Check Next Block
     if (!isNextBlockWritable()) {
       // The Index is full and does not overwrite old
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     // Next block can be written, update Metadata
     currentWriteBlock = getNextWrite();
     currentWriteBlock->setSize(0);
     currentWriteBlock->setStoredPackets(0);
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   /**
@@ -475,21 +475,21 @@ class IndexedRingMemoryArray : public SerializeIF, public ArrayList<Index<T>, ui
       additionalInfo->serialize(buffer, size, maxSize, streamEndianness);
     }
     ReturnValue_t result = currentWriteBlock->serialize(buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     result = SerializeAdapter::serialize(&this->size, buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
 
     uint32_t i = 0;
-    while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+    while ((result == returnvalue::OK) && (i < this->size)) {
       result =
           SerializeAdapter::serialize(&this->entries[i], buffer, size, maxSize, streamEndianness);
       ++i;
     }
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     uint16_t crc = Calculate_CRC(crcBuffer, (*size - oldSize));
@@ -523,44 +523,44 @@ class IndexedRingMemoryArray : public SerializeIF, public ArrayList<Index<T>, ui
    */
 
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t result = returnvalue::OK;
     if (additionalInfo != NULL) {
       result = additionalInfo->deSerialize(buffer, size, streamEndianness);
     }
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
 
     Index<T> tempIndex;
     result = tempIndex.deSerialize(buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     uint32_t tempSize = 0;
     result = SerializeAdapter::deSerialize(&tempSize, buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     if (this->size != tempSize) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     uint32_t i = 0;
-    while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+    while ((result == returnvalue::OK) && (i < this->size)) {
       result = SerializeAdapter::deSerialize(&this->entries[i], buffer, size, streamEndianness);
       ++i;
     }
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
     typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
     for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
       if (*(cmp.value) == *(it.value)) {
         currentWriteBlock = it;
-        return HasReturnvaluesIF::RETURN_OK;
+        return returnvalue::OK;
       }
     }
     // Reached if current write block iterator is not found
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
   uint32_t getIndexAddress() const { return indexAddress; }

src/fsfw/container/PlacementFactory.h

@@ -40,7 +40,7 @@ class PlacementFactory {
     store_address_t tempId;
     uint8_t* pData = nullptr;
     ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T), &pData);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return nullptr;
     }
     T* temp = new (pData) T(std::forward<Args>(args)...);
@@ -51,12 +51,12 @@ class PlacementFactory {
    * This must be called by the user.
    *
    * @param thisElement Element to be destroyed
-   * @return RETURN_OK if the element was destroyed, different errors on failure
+   * @return returnvalue::OK if the element was destroyed, different errors on failure
    */
   template <typename T>
   ReturnValue_t destroy(T* thisElement) {
     if (thisElement == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     // Need to call destructor first, in case something was allocated by the object (shouldn't do
     // that, however).

src/fsfw/container/RingBufferBase.h

@@ -3,7 +3,7 @@
 
 #include <cstddef>
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 
 template <uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
@@ -58,18 +58,18 @@ class RingBufferBase {
   ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
     if (getAvailableReadData(n) >= amount) {
       incrementRead(amount, n);
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     } else {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
   }
 
   ReturnValue_t writeData(uint32_t amount) {
     if (availableWriteSpace() >= amount or overwriteOld) {
       incrementWrite(amount);
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     } else {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
   }
 

src/fsfw/container/SimpleRingBuffer.cpp

@@ -32,14 +32,14 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t** writePointer, size_t am
     size_t amountTillWrap = writeTillWrap();
     if (amountTillWrap < amount) {
       if ((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return returnvalue::FAILED;
       }
       excessBytes = amount - amountTillWrap;
     }
     *writePointer = &buffer[write];
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 
@@ -52,7 +52,7 @@ void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data, size_t amount) {
   if (data == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (amount > getMaxSize()) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -62,7 +62,7 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data, size_t amount) {
     sif::printError("SimpleRingBuffer::writeData: Amount of data too large\n");
 #endif
 #endif
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (availableWriteSpace() >= amount or overwriteOld) {
     size_t amountTillWrap = writeTillWrap();
@@ -74,9 +74,9 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data, size_t amount) {
       memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
     }
     incrementWrite(amount);
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 
@@ -89,7 +89,7 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount, bool incr
       // more data available than amount specified.
       amount = availableData;
     } else {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
   }
   if (trueAmount != nullptr) {
@@ -105,7 +105,7 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount, bool incr
   if (incrementReadPtr) {
     deleteData(amount, readRemaining);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 size_t SimpleRingBuffer::getExcessBytes() const { return excessBytes; }
@@ -124,12 +124,12 @@ ReturnValue_t SimpleRingBuffer::deleteData(size_t amount, bool deleteRemaining,
     if (deleteRemaining) {
       amount = availableData;
     } else {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
   }
   if (trueAmount != nullptr) {
     *trueAmount = amount;
   }
   incrementRead(amount, READ_PTR);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

src/fsfw/container/SimpleRingBuffer.h

@@ -47,8 +47,8 @@ class SimpleRingBuffer : public RingBufferBase<> {
    * Write to circular buffer and increment write pointer by amount.
    * @param data
    * @param amount
-   * @return -@c RETURN_OK if write operation was successful
-   * -@c RETURN_FAILED if
+   * @return -@c returnvalue::OK if write operation was successful
+   * -@c returnvalue::FAILED if
    */
   ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
@@ -95,8 +95,8 @@ class SimpleRingBuffer : public RingBufferBase<> {
    * If readRemaining was set to true, the true amount read will be assigned
    * to the passed value.
    * @return
-   * - @c RETURN_OK if data was read successfully
-   * - @c RETURN_FAILED if not enough data was available and readRemaining
+   * - @c returnvalue::OK if data was read successfully
+   * - @c returnvalue::FAILED if not enough data was available and readRemaining
    *      was set to false.
    */
   ReturnValue_t readData(uint8_t* data, size_t amount, bool incrementReadPtr = false,

src/fsfw/controller/ControllerBase.cpp

@@ -20,7 +20,7 @@ ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue
 
 ReturnValue_t ControllerBase::initialize() {
   ReturnValue_t result = SystemObject::initialize();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -28,7 +28,7 @@ ReturnValue_t ControllerBase::initialize() {
   if (parentId != objects::NO_OBJECT) {
     auto* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
     if (parent == nullptr) {
-      return RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     parentQueue = parent->getCommandQueue();
 
@@ -36,16 +36,16 @@ ReturnValue_t ControllerBase::initialize() {
   }
 
   result = healthHelper.initialize(parentQueue);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
   result = modeHelper.initialize(parentQueue);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 MessageQueueId_t ControllerBase::getCommandQueue() const { return commandQueue->getId(); }
@@ -53,19 +53,19 @@ MessageQueueId_t ControllerBase::getCommandQueue() const { return commandQueue->
 void ControllerBase::handleQueue() {
   CommandMessage command;
   ReturnValue_t result;
-  for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+  for (result = commandQueue->receiveMessage(&command); result == returnvalue::OK;
        result = commandQueue->receiveMessage(&command)) {
     result = modeHelper.handleModeCommand(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
 
     result = healthHelper.handleHealthCommand(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
     result = handleCommandMessage(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
     command.setToUnknownCommand();
@@ -96,7 +96,7 @@ void ControllerBase::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
   handleQueue();
   performControlOperation();
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}
@@ -106,7 +106,7 @@ ReturnValue_t ControllerBase::setHealth(HealthState health) {
     case HEALTHY:
     case EXTERNAL_CONTROL:
       healthHelper.setHealth(health);
-      return RETURN_OK;
+      return returnvalue::OK;
     default:
       return INVALID_HEALTH_STATE;
   }
@@ -117,4 +117,4 @@ void ControllerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }
 
 void ControllerBase::changeHK(Mode_t mode_, Submode_t submode_, bool enable) {}
 
-ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return HasReturnvaluesIF::RETURN_OK; }
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return returnvalue::OK; }

src/fsfw/controller/ControllerBase.h

@@ -18,8 +18,7 @@
 class ControllerBase : public HasModesIF,
                        public HasHealthIF,
                        public ExecutableObjectIF,
-                       public SystemObject,
-                       public HasReturnvaluesIF {
+                       public SystemObject {
  public:
   static const Mode_t MODE_NORMAL = 2;
 

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -12,7 +12,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
                                                     MessageQueueId_t commandedBy,
                                                     const uint8_t *data, size_t size) {
   /* Needs to be overriden and implemented by child class. */
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 object_id_t ExtendedControllerBase::getObjectId() const { return SystemObject::getObjectId(); }
@@ -23,7 +23,7 @@ uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
 
 ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *message) {
   ReturnValue_t result = actionHelper.handleActionMessage(message);
-  if (result == HasReturnvaluesIF::RETURN_OK) {
+  if (result == returnvalue::OK) {
     return result;
   }
   return poolManager.handleHousekeepingMessage(message);
@@ -32,30 +32,30 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *messa
 void ExtendedControllerBase::handleQueue() {
   CommandMessage command;
   ReturnValue_t result;
-  for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+  for (result = commandQueue->receiveMessage(&command); result == returnvalue::OK;
        result = commandQueue->receiveMessage(&command)) {
     result = actionHelper.handleActionMessage(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
 
     result = modeHelper.handleModeCommand(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
 
     result = healthHelper.handleHealthCommand(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
 
     result = poolManager.handleHousekeepingMessage(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
 
     result = handleCommandMessage(&command);
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       continue;
     }
     command.setToUnknownCommand();
@@ -65,11 +65,11 @@ void ExtendedControllerBase::handleQueue() {
 
 ReturnValue_t ExtendedControllerBase::initialize() {
   ReturnValue_t result = ControllerBase::initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = actionHelper.initialize(commandQueue);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -86,7 +86,7 @@ ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
   /* We do this after performing control operation because variables will be set changed
   in this function. */
   poolManager.performHkOperation();
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 MessageQueueId_t ExtendedControllerBase::getCommandQueue() const { return commandQueue->getId(); }

src/fsfw/coordinates/Sgp4Propagator.cpp

@@ -152,7 +152,7 @@ ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1, const uint8_t* li
     return MAKE_RETURN_CODE(result);
   } else {
     initialized = true;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 }
 
@@ -195,6 +195,6 @@ ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity, time
   if (result != 0) {
     return MAKE_RETURN_CODE(result || 0xB0);
   } else {
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 }

src/fsfw/coordinates/Sgp4Propagator.h

@@ -7,7 +7,7 @@
 #ifndef PLATFORM_WIN
 #include <sys/time.h>
 #endif
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_contrib/sgp4/sgp4unit.h"
 
 class Sgp4Propagator {

src/fsfw/datalinklayer/CCSDSReturnValuesIF.h

@@ -9,12 +9,12 @@
 #define CCSDSRETURNVALUESIF_H_
 
 #include "dllConf.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 /**
  * This is a helper class to collect special return values that come up during CCSDS Handling.
  * @ingroup ccsds_handling
  */
-class CCSDSReturnValuesIF : public HasReturnvaluesIF {
+class CCSDSReturnValuesIF {
  public:
   static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;  //!< Basic ID of the interface.
 

src/fsfw/datalinklayer/DataLinkLayer.cpp

@@ -28,7 +28,7 @@ ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
   TcTransferFrame frame_candidate(frameBuffer);
   this->currentFrame = frame_candidate;  // should work with shallow copy.
 
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t DataLinkLayer::frameValidationCheck() {
@@ -59,14 +59,14 @@ ReturnValue_t DataLinkLayer::frameValidationCheck() {
   if (USE_CRC) {
     return this->frameCheckCRC();
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t DataLinkLayer::frameCheckCRC() {
   uint16_t checkValue =
       CRC::crc16ccitt(this->currentFrame.getFullFrame(), this->currentFrame.getFullSize());
   if (checkValue == 0) {
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
     return CRC_FAILED;
   }
@@ -74,7 +74,7 @@ ReturnValue_t DataLinkLayer::frameCheckCRC() {
 
 ReturnValue_t DataLinkLayer::allFramesReception() {
   ReturnValue_t status = this->frameDelimitingAndFillRemoval();
-  if (status != RETURN_OK) {
+  if (status != returnvalue::OK) {
     return status;
   }
   return this->frameValidationCheck();
@@ -90,7 +90,7 @@ ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
   virtualChannelIterator iter = virtualChannels.find(vcId);
   if (iter == virtualChannels.end()) {
     // Do not report because passive board will get this error all the time.
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
     return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
   }
@@ -99,7 +99,7 @@ ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
 ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
   receivedDataLength = length;
   ReturnValue_t status = allFramesReception();
-  if (status != RETURN_OK) {
+  if (status != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "DataLinkLayer::processFrame: frame reception failed. "
                   "Error code: "
@@ -117,14 +117,14 @@ ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
   std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
       std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
   if (returnValue.second == true) {
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 
 ReturnValue_t DataLinkLayer::initialize() {
-  ReturnValue_t returnValue = RETURN_FAILED;
+  ReturnValue_t returnValue = returnvalue::FAILED;
   // Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to
   // avoid faulty information (e.g. 0) in the VCID.
   if (virtualChannels.begin() != virtualChannels.end()) {
@@ -133,13 +133,13 @@ ReturnValue_t DataLinkLayer::initialize() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
 #endif
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
   for (virtualChannelIterator iterator = virtualChannels.begin(); iterator != virtualChannels.end();
        iterator++) {
     returnValue = iterator->second->initialize();
-    if (returnValue != RETURN_OK) break;
+    if (returnValue != returnvalue::OK) break;
   }
   return returnValue;
 }

src/fsfw/datalinklayer/DataLinkLayer.h

@@ -51,7 +51,7 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
    * This method tries to process a frame that is placed in #frameBuffer.
    * The procedures described in the Standard are performed.
    * @param length	Length of the incoming frame candidate.
-   * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher
+   * @return	@c returnvalue::OK on successful handling, otherwise the return codes of the higher
    * methods.
    */
   ReturnValue_t processFrame(uint16_t length);
@@ -61,12 +61,12 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
    * handle Frames directed to this VC.
    * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
    * @param object	Reference to the object that handles the Frame.
-   * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+   * @return	@c returnvalue::OK on success, @c returnvalue::FAILED otherwise.
    */
   ReturnValue_t addVirtualChannel(uint8_t virtualChannelId, VirtualChannelReceptionIF* object);
   /**
    * The initialization method calls the @c initialize routine of all virtual channels.
-   * @return The return code of the first failed VC initialization or @c RETURN_OK.
+   * @return The return code of the first failed VC initialization or @c returnvalue::OK.
    */
   ReturnValue_t initialize();
 
@@ -91,19 +91,19 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
       virtualChannels;  //!< Map of all virtual channels assigned.
   /**
    * Method that performs all possible frame validity checks (as specified).
-   * @return	Various error codes or @c RETURN_OK on success.
+   * @return	Various error codes or @c returnvalue::OK on success.
    */
   ReturnValue_t frameValidationCheck();
   /**
    * First method to call.
    * Removes start sequence bytes and checks if the complete frame was received.
    * SHOULDDO: Maybe handling the start sequence must be done more variable.
-   * @return @c RETURN_OK or @c TOO_SHORT.
+   * @return @c returnvalue::OK or @c TOO_SHORT.
    */
   ReturnValue_t frameDelimitingAndFillRemoval();
   /**
    * Small helper method to check the CRC of the Frame.
-   * @return @c RETURN_OK or @c CRC_FAILED.
+   * @return @c returnvalue::OK or @c CRC_FAILED.
    */
   ReturnValue_t frameCheckCRC();
   /**

src/fsfw/datalinklayer/Farm1StateOpen.cpp

@@ -11,7 +11,7 @@ ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame, ClcwIF* clcw
   if (diff == 0) {
     myVC->vR++;
     clcw->setRetransmitFlag(false);
-    return RETURN_OK;
+    return returnvalue::OK;
   } else if (diff < myVC->positiveWindow && diff > 0) {
     clcw->setRetransmitFlag(true);
     return NS_POSITIVE_W;

src/fsfw/datalinklayer/Farm1StateOpen.h

@@ -37,8 +37,8 @@ class Farm1StateOpen : public Farm1StateIF {
    * change to Farm1StateLockout.
    * @param frame	The frame to handle.
    * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-   * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
-   * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
+   * @return If the Sequence Number is ok, it returns returnvalue::OK. Otherwise either
+   * #NS_POSITIVE_W, #NS_NEGATIVE_W or NS_LOCKOUT is returned.
    */
   ReturnValue_t handleADFrame(TcTransferFrame* frame, ClcwIF* clcw);
   /**

src/fsfw/datalinklayer/MapPacketExtraction.cpp

@@ -31,7 +31,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
       if (packetLength <= MAX_PACKET_SIZE) {
         memcpy(packetBuffer, frame->getDataField(), packetLength);
         bufferPosition = &packetBuffer[packetLength];
-        status = RETURN_OK;
+        status = returnvalue::OK;
       } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "MapPacketExtraction::extractPackets. Packet too large! Size: "
@@ -52,7 +52,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
             status = sendCompletePacket(packetBuffer, packetLength);
             clearBuffers();
           }
-          status = RETURN_OK;
+          status = returnvalue::OK;
         } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
           sif::error << "MapPacketExtraction::extractPackets. Packet too large! Size: "
@@ -95,7 +95,7 @@ ReturnValue_t MapPacketExtraction::unpackBlockingPackets(TcTransferFrame* frame)
       status = sendCompletePacket(packet.getWholeData(), packet.getFullSize());
       totalLength -= packet.getFullSize();
       position += packet.getFullSize();
-      status = RETURN_OK;
+      status = returnvalue::OK;
     } else {
       status = DATA_CORRUPTED;
       totalLength = 0;
@@ -110,7 +110,7 @@ ReturnValue_t MapPacketExtraction::unpackBlockingPackets(TcTransferFrame* frame)
 ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data, uint32_t size) {
   store_address_t store_id;
   ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
-  if (status == RETURN_OK) {
+  if (status == returnvalue::OK) {
     TmTcMessage message(store_id);
     status = MessageQueueSenderIF::sendMessage(tcQueueId, &message);
   }
@@ -130,9 +130,9 @@ ReturnValue_t MapPacketExtraction::initialize() {
       ObjectManager::instance()->get<AcceptsTelecommandsIF>(packetDestination);
   if ((packetStore != NULL) && (distributor != NULL)) {
     tcQueueId = distributor->getRequestQueue();
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 

src/fsfw/datalinklayer/MapPacketExtraction.h

@@ -5,7 +5,7 @@
 #include "dllConf.h"
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 
 class StorageManagerIF;
 
@@ -36,7 +36,7 @@ class MapPacketExtraction : public MapPacketExtractionIF {
    * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
    * The method extracts one or more packets within the frame and forwards them to the OBSW.
    * @param frame	The TC Transfer Frame to work on.
-   * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
+   * @return	@c returnvalue::OK if all Packets were extracted. If something is entirely wrong,
    * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
    */
   ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
@@ -63,7 +63,7 @@ class MapPacketExtraction : public MapPacketExtractionIF {
   ReturnValue_t extractPackets(TcTransferFrame* frame);
   /**
    * The #packetStore and the default destination of #tcQueue are initialized here.
-   * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+   * @return	@c returnvalue::OK on success, @c returnvalue::FAILED otherwise.
    */
   ReturnValue_t initialize();
   /**

src/fsfw/datalinklayer/VirtualChannelReception.cpp

@@ -57,18 +57,18 @@ ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* cl
 
 ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
                                                                             ClcwIF* clcw) {
-  ReturnValue_t result = RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   result = doFARM(frame, &internalClcw);
   internalClcw.setReceiverFrameSequenceNumber(vR);
   internalClcw.setFarmBCount(farmBCounter);
   clcw->setWhole(internalClcw.getAsWhole());
   switch (result) {
-    case RETURN_OK:
+    case returnvalue::OK:
       return mapDemultiplexing(frame);
     case BC_IS_SET_VR_COMMAND:
     case BC_IS_UNLOCK_COMMAND:
       // Need to catch these codes to avoid error reporting later.
-      return RETURN_OK;
+      return returnvalue::OK;
     default:
       break;
   }
@@ -79,15 +79,15 @@ ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExt
   std::pair<mapChannelIterator, bool> returnValue =
       mapChannels.insert(std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
   if (returnValue.second == true) {
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 
 ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
   farmBCounter++;
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
@@ -107,18 +107,18 @@ ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, Clc
 uint8_t VirtualChannelReception::getChannelId() const { return channelId; }
 
 ReturnValue_t VirtualChannelReception::initialize() {
-  ReturnValue_t returnValue = RETURN_FAILED;
+  ReturnValue_t returnValue = returnvalue::FAILED;
   if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
                << (int)slidingWindowWidth << std::endl;
 #endif
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
        iterator++) {
     returnValue = iterator->second->initialize();
-    if (returnValue != RETURN_OK) break;
+    if (returnValue != returnvalue::OK) break;
   }
   return returnValue;
 }

src/fsfw/datalinklayer/VirtualChannelReception.h

@@ -77,7 +77,7 @@ class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSRe
    * required.
    * @param frame	The Tc Transfer Frame to handle.
    * @param clcw	Any changes on the CLCW shall be done with this method.
-   * @return Always returns @c RETURN_OK.
+   * @return Always returns @c returnvalue::OK.
    */
   ReturnValue_t handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw);
   /**
@@ -102,13 +102,14 @@ class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSRe
    * Helper method to simplify adding a mapChannel during construction.
    * @param mapId	The mapId of the object to add.
    * @param object	Pointer to the MapPacketExtraction object itself.
-   * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
+   * @return	@c returnvalue::OK if the channel was successfully inserted, @c returnvalue::FAILED
+   * otherwise.
    */
   ReturnValue_t addMapChannel(uint8_t mapId, MapPacketExtractionIF* object);
   /**
    * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
    * channels.
-   * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
+   * @return	@c returnvalue::OK on successful initialization, @c returnvalue::FAILED otherwise.
    */
   ReturnValue_t initialize();
   /**

src/fsfw/datalinklayer/VirtualChannelReceptionIF.h

@@ -11,7 +11,7 @@
 #include "ClcwIF.h"
 #include "TcTransferFrame.h"
 #include "dllConf.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 
 /**
  * This is the interface for Virtual Channel reception classes.
@@ -33,13 +33,13 @@ class VirtualChannelReceptionIF {
    * Handling the Frame includes forwarding to higher-level procedures.
    * @param frame	The Tc Transfer Frame that was received and checked.
    * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
-   * @return The return Value shall indicate successful processing with @c RETURN_OK.
+   * @return The return Value shall indicate successful processing with @c returnvalue::OK.
    */
   virtual ReturnValue_t frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
                                                              ClcwIF* clcw) = 0;
   /**
    * If any other System Objects are required for operation they shall be initialized here.
-   * @return	@c RETURN_OK for successful initialization.
+   * @return	@c returnvalue::OK for successful initialization.
    */
   virtual ReturnValue_t initialize() = 0;
   /**

src/fsfw/datapool/DataSetIF.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOL_DATASETIF_H_
 #define FSFW_DATAPOOL_DATASETIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 #include "../timemanager/Clock.h"
 class PoolVariableIF;
 

src/fsfw/datapool/PoolDataSetBase.cpp

@@ -14,7 +14,7 @@ PoolDataSetBase::~PoolDataSetBase() {}
 ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) {
   if (registeredVariables == nullptr) {
     /* Underlying container invalid */
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   if (state != States::STATE_SET_UNINITIALISED) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -42,17 +42,17 @@ ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) {
   }
   registeredVariables[fillCount] = variable;
   fillCount++;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   ReturnValue_t error = result;
   if (state == States::STATE_SET_UNINITIALISED) {
     lockDataPool(timeoutType, lockTimeout);
     for (uint16_t count = 0; count < fillCount; count++) {
       result = readVariable(count);
-      if (result != RETURN_OK) {
+      if (result != returnvalue::OK) {
         error = result;
       }
     }
@@ -71,7 +71,7 @@ ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t l
     result = SET_WAS_ALREADY_READ;
   }
 
-  if (error != HasReturnvaluesIF::RETURN_OK) {
+  if (error != returnvalue::OK) {
     result = error;
   }
   return result;
@@ -80,10 +80,10 @@ ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t l
 uint16_t PoolDataSetBase::getFillCount() const { return fillCount; }
 
 ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   if (registeredVariables[count] == nullptr) {
     /* Configuration error. */
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
   /* These checks are often performed by the respective variable implementation too, but I guess
@@ -98,7 +98,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
       result = ReadCommitIFAttorney::readWithoutLock(registeredVariables[count]);
     }
 
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       result = INVALID_PARAMETER_DEFINITION;
     }
   }
@@ -108,7 +108,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
   if (state == States::STATE_SET_WAS_READ) {
     handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   } else {
     return handleUnreadDatasetCommit(timeoutType, lockTimeout);
   }
@@ -134,7 +134,7 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(MutexIF::TimeoutType timeou
 
 ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(MutexIF::TimeoutType timeoutType,
                                                          uint32_t lockTimeout) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   lockDataPool(timeoutType, lockTimeout);
   for (uint16_t count = 0; count < fillCount; count++) {
     if ((registeredVariables[count]->getReadWriteMode() == PoolVariableIF::VAR_WRITE) and
@@ -165,17 +165,17 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(MutexIF::TimeoutType ti
 
 ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
                                             uint32_t lockTimeout) {
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
-ReturnValue_t PoolDataSetBase::unlockDataPool() { return HasReturnvaluesIF::RETURN_OK; }
+ReturnValue_t PoolDataSetBase::unlockDataPool() { return returnvalue::OK; }
 
 ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
                                          SerializeIF::Endianness streamEndianness) const {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   for (uint16_t count = 0; count < fillCount; count++) {
     result = registeredVariables[count]->serialize(buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -184,10 +184,10 @@ ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size, const s
 
 ReturnValue_t PoolDataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
                                            SerializeIF::Endianness streamEndianness) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   for (uint16_t count = 0; count < fillCount; count++) {
     result = registeredVariables[count]->deSerialize(buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }

src/fsfw/datapool/PoolDataSetBase.h

@@ -29,20 +29,20 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasReturnvaluesIF {
+class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
  public:
   /**
    * @brief	Creates an empty dataset. Use registerVariable or
    * 			supply a pointer to this dataset to PoolVariable
    * 			initializations to register pool variables.
    */
-  PoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxFillCount);
+  PoolDataSetBase(PoolVariableIF** registeredVariablesArray, size_t maxFillCount);
 
   /* Forbidden for now */
   PoolDataSetBase(const PoolDataSetBase& otherSet) = delete;
   const PoolDataSetBase& operator=(const PoolDataSetBase& otherSet) = delete;
 
-  virtual ~PoolDataSetBase();
+  ~PoolDataSetBase() override;
 
   /**
    * @brief	The read call initializes reading out all registered variables.
@@ -58,7 +58,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * freed afterwards. It is mandatory to call commit after a read call,
    * even if the read operation is not successful!
    * @return
-   * - @c RETURN_OK if all variables were read successfully.
+   * - @c returnvalue::OK if all variables were read successfully.
    * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
    *      is a type conflict.
    * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
@@ -80,7 +80,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
    * commit() can only be called after read(). If the set only contains
    * variables which are write only, commit() can be called without a
    * preceding read() call. Every read call must be followed by a commit call!
-   * @return	- @c RETURN_OK if all variables were read successfully.
+   * @return	- @c returnvalue::OK if all variables were read successfully.
    * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
    * 			  contains non write-only variables
    */
@@ -97,7 +97,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
   /**
    * Provides the means to lock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
-   * @return Always returns -@c RETURN_OK
+   * @return Always returns -@c returnvalue::OK
    */
   virtual ReturnValue_t lockDataPool(
       MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
@@ -105,7 +105,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF, public HasRetu
   /**
    * Provides the means to unlock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
-   * @return Always returns -@c RETURN_OK
+   * @return Always returns -@c returnvalue::OK
    */
   virtual ReturnValue_t unlockDataPool() override;
 

src/fsfw/datapool/PoolReadGuard.h

@@ -17,7 +17,7 @@ class PoolReadGuard {
       : readObject(readObject), mutexTimeout(mutexTimeout) {
     if (readObject != nullptr) {
       readResult = readObject->read(timeoutType, mutexTimeout);
-      if (readResult != HasReturnvaluesIF::RETURN_OK) {
+      if (readResult != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "PoolReadHelper: Read failed!" << std::endl;
@@ -47,7 +47,7 @@ class PoolReadGuard {
 
  private:
   ReadCommitIF* readObject = nullptr;
-  ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t readResult = returnvalue::OK;
   bool noCommit = false;
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t mutexTimeout = 20;

src/fsfw/datapool/PoolVariableIF.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
 #define FSFW_DATAPOOL_POOLVARIABLEIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 #include "../serialize/SerializeIF.h"
 #include "ReadCommitIF.h"
 

src/fsfw/datapool/ReadCommitIF.h

@@ -2,7 +2,7 @@
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
 #include "../ipc/MutexIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit

src/fsfw/datapool/ReadCommitIFAttorney.h

@@ -2,7 +2,7 @@
 #define FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
 
 #include <fsfw/datapool/ReadCommitIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
 
 /**
  * @brief   This class determines which members are allowed to access protected members
@@ -12,14 +12,14 @@ class ReadCommitIFAttorney {
  private:
   static ReturnValue_t readWithoutLock(ReadCommitIF* readCommitIF) {
     if (readCommitIF == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     return readCommitIF->readWithoutLock();
   }
 
   static ReturnValue_t commitWithoutLock(ReadCommitIF* readCommitIF) {
     if (readCommitIF == nullptr) {
-      return HasReturnvaluesIF::RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     return readCommitIF->commitWithoutLock();
   }

src/fsfw/datapoollocal/HasLocalDataPoolIF.h

@@ -110,10 +110,10 @@ class HasLocalDataPoolIF {
    * These function can be implemented by pool owner, if they are required
    * and used by the housekeeping message interface.
    * */
-  virtual ReturnValue_t addDataSet(sid_t sid) { return HasReturnvaluesIF::RETURN_FAILED; };
-  virtual ReturnValue_t removeDataSet(sid_t sid) { return HasReturnvaluesIF::RETURN_FAILED; };
+  virtual ReturnValue_t addDataSet(sid_t sid) { return returnvalue::FAILED; };
+  virtual ReturnValue_t removeDataSet(sid_t sid) { return returnvalue::FAILED; };
   virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   };
 
   /**

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -21,15 +21,15 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQue
                                            bool appendValidityBuffer)
     : appendValidityBuffer(appendValidityBuffer) {
   if (owner == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager",
-                        HasReturnvaluesIF::RETURN_FAILED, "Invalid supplied owner");
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager", returnvalue::FAILED,
+                        "Invalid supplied owner");
     return;
   }
   this->owner = owner;
   mutex = MutexFactory::instance()->createMutex();
   if (mutex == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "LocalDataPoolManager",
-                        HasReturnvaluesIF::RETURN_FAILED, "Could not create mutex");
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "LocalDataPoolManager", returnvalue::FAILED,
+                        "Could not create mutex");
   }
 
   hkQueue = queueToUse;
@@ -51,9 +51,9 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   if (ipcStore == nullptr) {
     /* Error, all destinations invalid */
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", returnvalue::FAILED,
                         "Could not set IPC store.");
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
   if (defaultHkDestination != objects::NO_OBJECT) {
@@ -67,7 +67,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     }
   }
 
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(uint8_t nonDiagInvlFactor) {
@@ -78,19 +78,19 @@ ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(uint8_t nonDiagI
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
   if (not mapInitialized) {
     ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap, *this);
-    if (result == HasReturnvaluesIF::RETURN_OK) {
+    if (result == returnvalue::OK) {
       mapInitialized = true;
     }
     return result;
   }
 
   printWarningOrError(sif::OutputTypes::OUT_WARNING, "initializeHousekeepingPoolEntriesOnce",
-                      HasReturnvaluesIF::RETURN_FAILED, "The map should only be initialized once");
-  return HasReturnvaluesIF::RETURN_OK;
+                      returnvalue::FAILED, "The map should only be initialized once");
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t status = returnvalue::OK;
   for (auto& receiver : hkReceivers) {
     switch (receiver.reportingType) {
       case (ReportingType::PERIODIC): {
@@ -115,7 +115,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
       }
       default:
         // This should never happen.
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return returnvalue::FAILED;
     }
   }
   resetHkUpdateResetHelper();
@@ -125,7 +125,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver, ReturnValue_t& status) {
   if (receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
     /* Update packets shall only be generated from datasets. */
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   LocalPoolDataSetBase* dataSet =
       HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
@@ -135,12 +135,12 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver, ReturnV
   if (dataSet->hasChanged()) {
     /* Prepare and send update notification */
     ReturnValue_t result = generateHousekeepingPacket(receiver.dataId.sid, dataSet, true);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       status = result;
     }
   }
   handleChangeResetLogic(receiver.dataType, receiver.dataId, dataSet);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
@@ -160,7 +160,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
       HousekeepingMessage::setUpdateNotificationVariableCommand(
           &notification, gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId));
       ReturnValue_t result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         status = result;
       }
       toReset = poolObj;
@@ -179,7 +179,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
       CommandMessage notification;
       HousekeepingMessage::setUpdateNotificationSetCommand(&notification, receiver.dataId.sid);
       ReturnValue_t result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
+      if (result != returnvalue::OK) {
         status = result;
       }
       toReset = dataSet;
@@ -188,7 +188,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
   if (toReset != nullptr) {
     handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& receiver,
@@ -205,7 +205,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     if (not poolObj->hasChanged()) {
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
 
     /* Prepare and send update snapshot */
@@ -219,7 +219,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
 
     store_address_t storeId;
     ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
 
@@ -227,7 +227,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     HousekeepingMessage::setUpdateSnapshotVariableCommand(
         &notification, gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId), storeId);
     result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       status = result;
     }
     toReset = poolObj;
@@ -241,7 +241,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     if (not dataSet->hasChanged()) {
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
 
     /* Prepare and send update snapshot */
@@ -255,14 +255,14 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
 
     store_address_t storeId;
     ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
 
     CommandMessage notification;
     HousekeepingMessage::setUpdateSnapshotSetCommand(&notification, receiver.dataId.sid, storeId);
     result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       status = result;
     }
     toReset = dataSet;
@@ -270,7 +270,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
   if (toReset != nullptr) {
     handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::addUpdateToStore(HousekeepingSnapshot& updatePacket,
@@ -279,7 +279,7 @@ ReturnValue_t LocalDataPoolManager::addUpdateToStore(HousekeepingSnapshot& updat
   uint8_t* storePtr = nullptr;
   ReturnValue_t result =
       ipcStore->getFreeElement(&storeId, updatePacket.getSerializedSize(), &storePtr);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   size_t serializedSize = 0;
@@ -356,7 +356,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(subdp::ParamsBase
   }
 
   hkReceivers.push_back(hkReceiver);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForRegularUpdatePacket(
@@ -388,7 +388,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(subdp::ParamsBase&
   hkReceivers.push_back(hkReceiver);
 
   handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessage(const uint32_t setId,
@@ -409,7 +409,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessage(const uint32_t
   hkReceivers.push_back(hkReceiver);
 
   handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
@@ -429,7 +429,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
   hkReceivers.push_back(hkReceiver);
 
   handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, DataId dataId) {
@@ -463,7 +463,7 @@ void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, D
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* message) {
   Command_t command = message->getCommand();
   sid_t sid = HousekeepingMessage::getSid(message);
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   switch (command) {
     // Houskeeping interface handling.
     case (HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
@@ -488,7 +488,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 
     case (HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
       result = generateSetStructurePacket(sid, true);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
+      if (result == returnvalue::OK) {
         return result;
       }
       break;
@@ -496,7 +496,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 
     case (HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
       result = generateSetStructurePacket(sid, false);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
+      if (result == returnvalue::OK) {
         return result;
       }
       break;
@@ -536,12 +536,12 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
     /* Notification handling */
     case (HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
       owner->handleChangedDataset(sid);
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
     case (HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
       gp_id_t globPoolId = HousekeepingMessage::getUpdateNotificationVariableCommand(message);
       owner->handleChangedPoolVariable(globPoolId);
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
     case (HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
       store_address_t storeId;
@@ -551,7 +551,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
       if (clearMessage) {
         message->clear();
       }
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
     case (HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
       store_address_t storeId;
@@ -561,7 +561,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
       if (clearMessage) {
         message->clear();
       }
-      return HasReturnvaluesIF::RETURN_OK;
+      return returnvalue::OK;
     }
 
     default:
@@ -569,7 +569,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
   }
 
   CommandMessage reply;
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
   } else {
     HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
@@ -586,7 +586,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(lp_id_t localPoolId) {
     return localpool::POOL_ENTRY_NOT_FOUND;
   }
   poolIter->second->print();
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() { return mutex; }
@@ -609,7 +609,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
   size_t serializedSize = 0;
   ReturnValue_t result =
       serializeHkPacketIntoStore(hkPacket, storeId, forDownlink, &serializedSize);
-  if (result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+  if (result != returnvalue::OK or serializedSize == 0) {
     return result;
   }
 
@@ -647,7 +647,7 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(HousekeepingPacke
   uint8_t* dataPtr = nullptr;
   const size_t maxSize = hkPacket.getSerializedSize();
   ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize, &dataPtr);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -687,7 +687,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   }
 
   ReturnValue_t result = generateHousekeepingPacket(sid, dataSet, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
@@ -718,7 +718,7 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, bool ena
   }
 
   LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float newCollectionInterval,
@@ -744,7 +744,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float ne
   }
 
   periodicHelper->changeCollectionInterval(newCollectionInterval);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool isDiagnostics) {
@@ -772,24 +772,22 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   uint8_t* storePtr = nullptr;
   store_address_t storeId;
   ReturnValue_t result = ipcStore->getFreeElement(&storeId, expectedSize, &storePtr);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     printWarningOrError(sif::OutputTypes::OUT_ERROR, "generateSetStructurePacket",
-                        HasReturnvaluesIF::RETURN_FAILED,
-                        "Could not get free element from IPC store.");
+                        returnvalue::FAILED, "Could not get free element from IPC store.");
     return result;
   }
 
   // Serialize set packet into store.
   size_t size = 0;
   result = setPacket.serialize(&storePtr, &size, expectedSize, SerializeIF::Endianness::BIG);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ipcStore->deleteData(storeId);
     return result;
   }
   if (expectedSize != size) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
-                        HasReturnvaluesIF::RETURN_FAILED,
-                        "Expected size is not equal to serialized size");
+                        returnvalue::FAILED, "Expected size is not equal to serialized size");
   }
 
   // Send structure reporting reply.
@@ -801,7 +799,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   }
 
   result = hkQueue->reply(&reply);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     ipcStore->deleteData(storeId);
   }
   return result;
@@ -827,7 +825,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
       errorPrint = "Dataset not found";
     } else if (error == POOLOBJECT_NOT_FOUND) {
       errorPrint = "Pool Object not found";
-    } else if (error == HasReturnvaluesIF::RETURN_FAILED) {
+    } else if (error == returnvalue::FAILED) {
       if (outputType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";
       } else {

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -361,7 +361,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
 
   void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
-                           ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+                           ReturnValue_t errorCode = returnvalue::FAILED,
                            const char* errorPrint = nullptr);
 };
 
@@ -369,7 +369,7 @@ template <class T>
 inline ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
                                                           PoolEntry<T>** poolEntry) {
   if (poolEntry == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 
   auto poolIter = localPoolMap.find(localPoolId);
@@ -385,7 +385,7 @@ inline ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
                         localpool::POOL_ENTRY_TYPE_CONFLICT);
     return localpool::POOL_ENTRY_TYPE_CONFLICT;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -85,13 +85,13 @@ ReturnValue_t LocalPoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutTyp
   if (mutexIfSingleDataCreator != nullptr) {
     return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(
     uint8_t **buffer, size_t *size, size_t maxSize,
     SerializeIF::Endianness streamEndianness) const {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  ReturnValue_t result = returnvalue::OK;
   const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount) / 8.0);
   uint8_t *validityPtr = nullptr;
 #if defined(_MSC_VER) || defined(__clang__)
@@ -119,7 +119,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(
     }
 
     result = registeredVariables[count]->serialize(buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -135,10 +135,10 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(
 
 ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     const uint8_t **buffer, size_t *size, SerializeIF::Endianness streamEndianness) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   for (uint16_t count = 0; count < fillCount; count++) {
     result = registeredVariables[count]->deSerialize(buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       return result;
     }
   }
@@ -169,7 +169,7 @@ ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
   if (mutexIfSingleDataCreator != nullptr) {
     return mutexIfSingleDataCreator->unlockMutex();
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t **buffer, size_t *size,
@@ -185,7 +185,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t **buffer, size
     lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
     auto result =
         SerializeAdapter::serialize(&currentPoolId, buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
                    << "Serialization error!" << std::endl;
@@ -197,7 +197,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t **buffer, size
       return result;
     }
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(bool serializeFillCount) const {

src/fsfw/datapoollocal/LocalPoolObjectBase.h

@@ -4,7 +4,7 @@
 #include "MarkChangedIF.h"
 #include "fsfw/datapool/PoolVariableIF.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "localPoolDefinitions.h"
 
 class LocalDataPoolManager;
@@ -15,7 +15,7 @@ class HasLocalDataPoolIF;
  * @brief 	This class serves as a non-template base for pool objects like pool variables
  * 			or pool vectors.
  */
-class LocalPoolObjectBase : public PoolVariableIF, public HasReturnvaluesIF, public MarkChangedIF {
+class LocalPoolObjectBase : public PoolVariableIF, public MarkChangedIF {
  public:
   LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
                       pool_rwm_t setReadWriteMode);

src/fsfw/datapoollocal/LocalPoolVariable.tpp

@@ -29,7 +29,7 @@ inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType
   }
   MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
   ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = readWithoutLock();
@@ -49,7 +49,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
   PoolEntry<T>* poolEntry = nullptr;
   ReturnValue_t result =
       LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     object_id_t ownerObjectId = hkManager->getCreatorObjectId();
     reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
     return result;
@@ -57,7 +57,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
   this->value = *(poolEntry->getDataPtr());
   this->valid = poolEntry->getValid();
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename T>
@@ -75,7 +75,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(MutexIF::TimeoutType timeoutTy
   }
   MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
   ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = commitWithoutLock();
@@ -95,7 +95,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
   PoolEntry<T>* poolEntry = nullptr;
   ReturnValue_t result =
       LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     object_id_t ownerObjectId = hkManager->getCreatorObjectId();
     reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
     return result;
@@ -103,7 +103,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 
   *(poolEntry->getDataPtr()) = this->value;
   poolEntry->setValid(this->valid);
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename T>

src/fsfw/datapoollocal/LocalPoolVector.tpp

@@ -43,14 +43,14 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
       LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
   memset(this->value, 0, vectorSize * sizeof(T));
 
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     object_id_t targetObjectId = hkManager->getCreatorObjectId();
     reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
     return result;
   }
   std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
   this->valid = poolEntry->getValid();
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename T, uint16_t vectorSize>
@@ -79,14 +79,14 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
   PoolEntry<T>* poolEntry = nullptr;
   ReturnValue_t result =
       LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     object_id_t targetObjectId = hkManager->getCreatorObjectId();
     reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
     return result;
   }
   std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
   poolEntry->setValid(this->valid);
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 template <typename T, uint16_t vectorSize>
@@ -131,10 +131,10 @@ template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(
     uint8_t** buffer, size_t* size, size_t maxSize,
     SerializeIF::Endianness streamEndianness) const {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   for (uint16_t i = 0; i < vectorSize; i++) {
     result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       break;
     }
   }
@@ -149,10 +149,10 @@ inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
 template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
     const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   for (uint16_t i = 0; i < vectorSize; i++) {
     result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != returnvalue::OK) {
       break;
     }
   }

src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h

@@ -4,7 +4,7 @@
 #include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/messageQueueDefinitions.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "localPoolDefinitions.h"
 
 namespace subdp {

src/fsfw/datapoollocal/SharedLocalDataSet.cpp

@@ -20,7 +20,7 @@ ReturnValue_t SharedLocalDataSet::lockDataset(MutexIF::TimeoutType timeoutType,
   if (datasetLock != nullptr) {
     return datasetLock->lockMutex(timeoutType, mutexTimeout);
   }
-  return HasReturnvaluesIF::RETURN_FAILED;
+  return returnvalue::FAILED;
 }
 
 SharedLocalDataSet::~SharedLocalDataSet() { MutexFactory::instance()->deleteMutex(datasetLock); }
@@ -29,5 +29,5 @@ ReturnValue_t SharedLocalDataSet::unlockDataset() {
   if (datasetLock != nullptr) {
     return datasetLock->unlockMutex();
   }
-  return HasReturnvaluesIF::RETURN_FAILED;
+  return returnvalue::FAILED;
 }

src/fsfw/devicehandlers/AssemblyBase.cpp

@@ -50,7 +50,7 @@ bool AssemblyBase::isInTransition() {
 bool AssemblyBase::handleChildrenChanged() {
   if (childrenChangedMode) {
     ReturnValue_t result = checkChildrenState();
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       handleChildrenLostMode(result);
     }
     return true;
@@ -116,7 +116,7 @@ void AssemblyBase::handleChildrenTransition() {
         break;
     }
     ReturnValue_t result = checkChildrenState();
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       handleModeReached();
     } else {
       handleModeTransitionFailed(result);
@@ -149,7 +149,7 @@ void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
 void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo, HealthState health) {
   CommandMessage command;
   HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET, health);
-  if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
+  if (commandQueue->sendMessage(sendTo, &command) == returnvalue::OK) {
     commandsOutstanding++;
   }
 }
@@ -164,25 +164,25 @@ ReturnValue_t AssemblyBase::checkChildrenState() {
 
 ReturnValue_t AssemblyBase::checkChildrenStateOff() {
   for (const auto& childIter : childrenMap) {
-    if (checkChildOff(childIter.first) != RETURN_OK) {
+    if (checkChildOff(childIter.first) != returnvalue::OK) {
       return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
     }
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
   ChildInfo childInfo = childrenMap.find(objectId)->second;
   if (healthHelper.healthTable->isCommandable(objectId)) {
     if (childInfo.submode != SUBMODE_NONE) {
-      return RETURN_FAILED;
+      return returnvalue::FAILED;
     } else {
       if ((childInfo.mode != MODE_OFF) && (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
-        return RETURN_FAILED;
+        return returnvalue::FAILED;
       }
     }
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
@@ -192,7 +192,7 @@ ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
     if (submode != SUBMODE_NONE) {
       return INVALID_SUBMODE;
     }
-    return RETURN_OK;
+    return returnvalue::OK;
   }
 
   if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
@@ -212,7 +212,7 @@ ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
     if (health != EXTERNAL_CONTROL) {
       updateChildChangedHealth(message->getSender(), true);
     }
-    return RETURN_OK;
+    return returnvalue::OK;
   }
   if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET ||
       (message->getCommand() == CommandMessage::REPLY_REJECTED &&
@@ -220,9 +220,9 @@ ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
     if (isInTransition()) {
       commandsOutstanding--;
     }
-    return RETURN_OK;
+    return returnvalue::OK;
   }
-  return RETURN_FAILED;
+  return returnvalue::FAILED;
 }
 
 bool AssemblyBase::checkAndHandleRecovery() {

src/fsfw/devicehandlers/AssemblyBase.h

@@ -53,7 +53,7 @@ class AssemblyBase : public SubsystemBase {
    * @param mode
    * @param submode
    * @return
-   *    - @c RETURN_OK if ok
+   *    - @c returnvalue::OK if ok
    *    - @c NEED_SECOND_STEP if children need to be commanded again
    */
   virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
@@ -79,7 +79,7 @@ class AssemblyBase : public SubsystemBase {
    * @param submode The targeted submmode
    * @return Any information why this combination is invalid from HasModesIF
    * 			like HasModesIF::INVALID_SUBMODE.
-   * 			On success return HasReturnvaluesIF::RETURN_OK
+   * 			On success return returnvalue::OK
    */
   virtual ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode) = 0;
 

src/fsfw/devicehandlers/ChildHandlerBase.cpp

@@ -19,7 +19,7 @@ ChildHandlerBase::~ChildHandlerBase() {}
 
 ReturnValue_t ChildHandlerBase::initialize() {
   ReturnValue_t result = DeviceHandlerBase::initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -28,7 +28,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
   if (parentId != objects::NO_OBJECT) {
     SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
     if (parent == NULL) {
-      return RETURN_FAILED;
+      return returnvalue::FAILED;
     }
     parentQueue = parent->getCommandQueue();
 
@@ -39,5 +39,5 @@ ReturnValue_t ChildHandlerBase::initialize() {
 
   modeHelper.setParentQueue(parentQueue);
 
-  return RETURN_OK;
+  return returnvalue::OK;
 }

src/fsfw/devicehandlers/DeviceCommunicationIF.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
 #define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/returnvalue.h"
 #include "CookieIF.h"
 #include "DeviceHandlerIF.h"
 /**
@@ -34,7 +34,7 @@
  *  @ingroup interfaces
  *  @ingroup comm
  */
-class DeviceCommunicationIF : public HasReturnvaluesIF {
+class DeviceCommunicationIF {
  public:
   static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
@@ -61,7 +61,7 @@ class DeviceCommunicationIF : public HasReturnvaluesIF {
    * initialization.
    * @param cookie
    * @return
-   *  - @c RETURN_OK if initialization was successfull
+   *  - @c returnvalue::OK if initialization was successfull
    *  - Everything else triggers failure event with returnvalue as parameter 1
    */
   virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0;
@@ -74,7 +74,7 @@ class DeviceCommunicationIF : public HasReturnvaluesIF {
    * @param data
    * @param len If this is 0, nothing shall be sent.
    * @return
-   *  - @c RETURN_OK for successfull send
+   *  - @c returnvalue::OK for successfull send
    *  - Everything else triggers failure event with returnvalue as parameter 1
    */
   virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) = 0;
@@ -84,7 +84,7 @@ class DeviceCommunicationIF : public HasReturnvaluesIF {
    * Get send confirmation that the data in sendMessage() was sent successfully.
    * @param cookie
    * @return
-   *  - @c RETURN_OK if data was sent successfully but a reply is expected
+   *  - @c returnvalue::OK if data was sent successfully but a reply is expected
    *  - NO_REPLY_EXPECTED if data was sent successfully and no reply is expected
    *  - Everything else to indicate failure
    */
@@ -99,7 +99,7 @@ class DeviceCommunicationIF : public HasReturnvaluesIF {
    *
    * @param cookie
    * @param requestLen Size of data to read
-   * @return - @c RETURN_OK to confirm the request for data has been sent.
+   * @return - @c returnvalue::OK to confirm the request for data has been sent.
    *         - Everything else triggers failure event with
    *           returnvalue as parameter 1
    */
@@ -113,7 +113,7 @@ class DeviceCommunicationIF : public HasReturnvaluesIF {
    * @param buffer [out] Set reply here (by using *buffer = ...)
    * @param size [out] size pointer to set (by using *size = ...).
    * 	           Set to 0 if no reply was received
-   * @return - @c RETURN_OK for successfull receive
+   * @return - @c returnvalue::OK for successfull receive
    * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
    * 		   	   0 has the same effect
    *         - Everything else triggers failure event with

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -32,7 +32,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
       parameterHelper(this),
       actionHelper(this, nullptr),
       poolManager(this, nullptr),
-      childTransitionFailure(RETURN_OK),
+      childTransitionFailure(returnvalue::OK),
       fdirInstance(fdirInstance),
       defaultFDIRUsed(fdirInstance == nullptr),
       switchOffWasReported(false),
@@ -45,8 +45,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
   cookieInfo.state = COOKIE_UNUSED;
   cookieInfo.pendingCommand = deviceCommandMap.end();
   if (comCookie == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
-                        HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase", returnvalue::FAILED,
+                        "Invalid cookie");
   }
   if (this->fdirInstance == nullptr) {
     this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
@@ -79,7 +79,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
   this->lastStep = this->pstStep;
 
   if (getComAction() == CommunicationAction::NOTHING) {
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
   }
 
   if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
@@ -90,11 +90,11 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
     decrementDeviceReplyMap();
     fdirInstance->checkForFailures();
     performOperationHook();
-    return RETURN_OK;
+    return returnvalue::OK;
   }
 
   if (mode == MODE_OFF) {
-    return RETURN_OK;
+    return returnvalue::OK;
   }
 
   switch (getComAction()) {
@@ -120,12 +120,12 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
     default:
       break;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t DeviceHandlerBase::initialize() {
   ReturnValue_t result = SystemObject::initialize();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -138,7 +138,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   }
 
   result = communicationInterface->initializeInterface(comCookie);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
                         ObjectManagerIF::CHILD_INIT_FAILED, "ComIF initialization failed");
     return result;
@@ -192,30 +192,30 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   }
 
   result = healthHelper.initialize();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
   result = modeHelper.initialize();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = actionHelper.initialize(commandQueue);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = fdirInstance->initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
   result = parameterHelper.initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
   result = poolManager.initialize(commandQueue);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
 
@@ -224,14 +224,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   if (thermalSet != nullptr) {
     // Set temperature target state to NON_OP.
     result = thermalSet->read();
-    if (result == HasReturnvaluesIF::RETURN_OK) {
+    if (result == returnvalue::OK) {
       thermalSet->heaterRequest.value = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
       thermalSet->heaterRequest.setValid(true);
       thermalSet->commit();
     }
   }
 
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -265,42 +265,42 @@ void DeviceHandlerBase::readCommandQueue() {
 
   CommandMessage command;
   ReturnValue_t result = commandQueue->receiveMessage(&command);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return;
   }
 
   result = healthHelper.handleHealthCommand(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
   result = modeHelper.handleModeCommand(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
   result = actionHelper.handleActionMessage(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
   result = parameterHelper.handleParameterMessage(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
   result = poolManager.handleHousekeepingMessage(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
   result = handleDeviceHandlerMessage(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
   result = letChildHandleMessage(&command);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     return;
   }
 
@@ -328,7 +328,7 @@ void DeviceHandlerBase::doStateMachine() {
         sprintf(printout, "Transition timeout (%lu) occured !",
                 static_cast<unsigned long>(childTransitionDelay));
         /* Common configuration error for development, so print it */
-        printWarningOrError(sif::OutputTypes::OUT_WARNING, "doStateMachine", RETURN_FAILED,
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "doStateMachine", returnvalue::FAILED,
                             printout);
 #endif
         triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
@@ -407,7 +407,7 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode, Submode_t s
     case MODE_NORMAL:
     case MODE_RAW:
       if (submode == SUBMODE_NONE) {
-        return RETURN_OK;
+        return returnvalue::OK;
       } else {
         return INVALID_SUBMODE;
       }
@@ -444,9 +444,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
   info.countdown = countdown;
   auto resultPair = deviceReplyMap.emplace(replyId, info);
   if (resultPair.second) {
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 
@@ -461,9 +461,9 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
   info.alternativeReplyId = alternativeReplyId;
   auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
   if (resultPair.second) {
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
 }
 
@@ -499,7 +499,7 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
     }
     info->delayCycles = delayCycles;
     info->periodic = periodic;
-    return RETURN_OK;
+    return returnvalue::OK;
   }
 }
 
@@ -529,17 +529,17 @@ ReturnValue_t DeviceHandlerBase::updatePeriodicReply(bool enable, DeviceCommandI
       }
     }
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
                                                  LocalPoolDataSetBase* dataSet) {
   auto replyIter = deviceReplyMap.find(replyId);
   if (replyIter == deviceReplyMap.end()) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   replyIter->second.dataSet = dataSet;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 void DeviceHandlerBase::callChildStatemachine() {
@@ -578,7 +578,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 
   if (mode == MODE_OFF and thermalSet != nullptr) {
     ReturnValue_t result = thermalSet->read();
-    if (result == HasReturnvaluesIF::RETURN_OK) {
+    if (result == returnvalue::OK) {
       if (thermalSet->heaterRequest.value != ThermalComponentIF::STATE_REQUEST_IGNORE) {
         thermalSet->heaterRequest.value = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
       }
@@ -593,7 +593,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode) { setMode(newMode, submode); }
 
 void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status, uint32_t parameter) {
   // This is actually the reply protocol for raw and misc DH commands.
-  if (status == RETURN_OK) {
+  if (status == returnvalue::OK) {
     CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
     commandQueue->reply(&reply);
   } else {
@@ -606,7 +606,7 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status, uint32_t parameter)
   // Check if we reply to a raw command.
   if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
     if (status == NO_REPLY_EXPECTED) {
-      status = RETURN_OK;
+      status = returnvalue::OK;
     }
     replyReturnvalueToCommand(status, parameter);
     // Always delete data from a raw command.
@@ -617,7 +617,7 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status, uint32_t parameter)
   if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
     MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
     if (status == NO_REPLY_EXPECTED) {
-      actionHelper.finish(true, queueId, cookieInfo.pendingCommand->first, RETURN_OK);
+      actionHelper.finish(true, queueId, cookieInfo.pendingCommand->first, returnvalue::OK);
     } else {
       actionHelper.step(1, queueId, cookieInfo.pendingCommand->first, status);
     }
@@ -634,8 +634,8 @@ void DeviceHandlerBase::replyToReply(const DeviceCommandId_t command, DeviceRepl
   }
   DeviceCommandInfo* info = &replyInfo.command->second;
   if (info == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "replyToReply",
-                        HasReturnvaluesIF::RETURN_FAILED, "Command pointer not found");
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "replyToReply", returnvalue::FAILED,
+                        "Command pointer not found");
     return;
   }
 
@@ -649,7 +649,7 @@ void DeviceHandlerBase::replyToReply(const DeviceCommandId_t command, DeviceRepl
     // Don't send any replies in that case.
     if (info->sendReplyTo != NO_COMMANDER) {
       bool success = false;
-      if (status == HasReturnvaluesIF::RETURN_OK) {
+      if (status == returnvalue::OK) {
         success = true;
       }
       actionHelper.finish(success, info->sendReplyTo, command, status);
@@ -662,7 +662,7 @@ void DeviceHandlerBase::doSendWrite() {
   if (cookieInfo.state == COOKIE_WRITE_READY) {
     ReturnValue_t result = communicationInterface->sendMessage(comCookie, rawPacket, rawPacketLen);
 
-    if (result == RETURN_OK) {
+    if (result == returnvalue::OK) {
       cookieInfo.state = COOKIE_WRITE_SENT;
     } else {
       // always generate a failure event, so that FDIR knows what's up
@@ -680,7 +680,7 @@ void DeviceHandlerBase::doGetWrite() {
   }
   cookieInfo.state = COOKIE_UNUSED;
   ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     if (wiretappingMode == RAW) {
       replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
     }
@@ -694,7 +694,7 @@ void DeviceHandlerBase::doGetWrite() {
     // always generate a failure event, so that FDIR knows what's up
     triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result, cookieInfo.pendingCommand->first);
   }
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     cookieInfo.pendingCommand->second.isExecuting = false;
   }
   replyToCommand(result);
@@ -704,7 +704,7 @@ void DeviceHandlerBase::doSendRead() {
   ReturnValue_t result;
 
   result = doSendReadHook();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     return;
   }
 
@@ -715,7 +715,7 @@ void DeviceHandlerBase::doSendRead() {
 
   result = communicationInterface->requestReceiveMessage(comCookie, replyLen);
 
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     cookieInfo.state = COOKIE_READ_SENT;
   } else {
     triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -741,7 +741,7 @@ void DeviceHandlerBase::doGetRead() {
   ReturnValue_t result =
       communicationInterface->readReceivedMessage(comCookie, &receivedData, &receivedDataLen);
 
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
     // I think we can allow to ignore one missedReply.
     ignoreMissedRepliesCount++;
@@ -764,7 +764,7 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData, size_t receivedDataLen) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND_ID;
   size_t foundLen = 0;
   /* The loop may not execute more often than the number of received bytes
@@ -773,7 +773,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData, size_t receivedD
   for (uint32_t count = 0; count < receivedDataLen; count++) {
     result = scanForReply(receivedData, remainingLength, &foundId, &foundLen);
     switch (result) {
-      case RETURN_OK:
+      case returnvalue::OK:
         handleReply(receivedData, foundId, foundLen);
         if (foundLen == 0) {
           printWarningOrError(sif::OutputTypes::OUT_WARNING, "parseReply",
@@ -783,7 +783,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData, size_t receivedD
         break;
       case APERIODIC_REPLY: {
         result = interpretDeviceReply(foundId, receivedData);
-        if (result != RETURN_OK) {
+        if (result != returnvalue::OK) {
           replyRawReplyIfnotWiretapped(receivedData, foundLen);
           triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
         }
@@ -846,7 +846,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, DeviceCommandId
       resetDelayCyclesControlledReply(info);
     }
 
-    if (result != RETURN_OK) {
+    if (result != returnvalue::OK) {
       // Report failed interpretation to FDIR.
       replyRawReplyIfnotWiretapped(receivedData, foundLen);
       triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
@@ -887,12 +887,12 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
   if (IPCStore == nullptr) {
     *data = nullptr;
     *len = 0;
-    return RETURN_FAILED;
+    return returnvalue::FAILED;
   }
   ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     *len = lenTmp;
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
     triggerEvent(StorageManagerIF::GET_DATA_FAILED, result, storageAddress.raw);
     *data = nullptr;
@@ -909,7 +909,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t* data, size_t len, MessageQue
   store_address_t address;
   ReturnValue_t result = IPCStore->addData(&address, data, len);
 
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
     return;
   }
@@ -921,7 +921,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t* data, size_t len, MessageQue
 
   result = commandQueue->sendMessage(sendTo, &command);
 
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     IPCStore->deleteData(address);
     // Silently discard data, this indicates heavy TM traffic which
     // should not be increased by additional events.
@@ -957,7 +957,7 @@ MessageQueueId_t DeviceHandlerBase::getCommandQueue() const { return commandQueu
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
   storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
   ReturnValue_t result = getStorageData(storedRawData, &rawPacket, &rawPacketLen);
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     replyReturnvalueToCommand(result, RAW_COMMAND_ID);
     storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
   } else {
@@ -974,7 +974,7 @@ void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
   const uint8_t* switches;
   uint8_t numberOfSwitches = 0;
   ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     while (numberOfSwitches > 0) {
       powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1], onOff);
       numberOfSwitches--;
@@ -982,7 +982,7 @@ void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
   }
 }
 
-ReturnValue_t DeviceHandlerBase::doSendReadHook() { return RETURN_OK; }
+ReturnValue_t DeviceHandlerBase::doSendReadHook() { return returnvalue::OK; }
 
 ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
   return DeviceHandlerBase::NO_SWITCH;
@@ -1011,7 +1011,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(DeviceCommandMap::iterato
       info->countdown->resetTimer();
     }
     info->active = true;
-    return RETURN_OK;
+    return returnvalue::OK;
   } else {
     return NO_REPLY_EXPECTED;
   }
@@ -1029,7 +1029,7 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
   const uint8_t* switches;
 
   ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-  if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
+  if ((result == returnvalue::OK) && (numberOfSwitches != 0)) {
     while (numberOfSwitches > 0) {
       if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1]) ==
           PowerSwitchIF::SWITCH_OFF) {
@@ -1074,7 +1074,7 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode, Submode_
 
   if ((commandedMode == MODE_ON) && (mode == MODE_OFF) and (thermalSet != nullptr)) {
     ReturnValue_t result = thermalSet->read();
-    if (result == HasReturnvaluesIF::RETURN_OK) {
+    if (result == returnvalue::OK) {
       if ((thermalSet->heaterRequest.value != ThermalComponentIF::STATE_REQUEST_IGNORE) and
           (not ThermalComponentIF::isOperational(thermalSet->thermalState.value))) {
         triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE, thermalSet->thermalState.value);
@@ -1134,7 +1134,7 @@ void DeviceHandlerBase::handleTransitionToOnMode(Mode_t commandedMode, Submode_t
     triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
     if (thermalSet != nullptr) {
       ReturnValue_t result = thermalSet->read();
-      if (result == HasReturnvaluesIF::RETURN_OK) {
+      if (result == returnvalue::OK) {
         if (thermalSet->heaterRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
           thermalSet->heaterRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
           thermalSet->commit();
@@ -1169,7 +1169,7 @@ HasHealthIF::HealthState DeviceHandlerBase::getHealth() { return healthHelper.ge
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
   healthHelper.setHealth(health);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 void DeviceHandlerBase::checkSwitchState() {
@@ -1191,7 +1191,7 @@ ReturnValue_t DeviceHandlerBase::acceptExternalDeviceCommands() {
   if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
     return WRONG_MODE_FOR_COMMAND;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data, size_t len) {
@@ -1220,10 +1220,10 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(CommandMessage* mess
         default:
           replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
           wiretappingMode = OFF;
-          return RETURN_OK;
+          return returnvalue::OK;
       }
-      replyReturnvalueToCommand(RETURN_OK);
-      return RETURN_OK;
+      replyReturnvalueToCommand(returnvalue::OK);
+      return returnvalue::OK;
     case DeviceHandlerMessage::CMD_RAW:
       if ((mode != MODE_RAW)) {
         DeviceHandlerMessage::clear(message);
@@ -1231,9 +1231,9 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(CommandMessage* mess
       } else {
         buildRawDeviceCommand(message);
       }
-      return RETURN_OK;
+      return returnvalue::OK;
     default:
-      return RETURN_FAILED;
+      return returnvalue::FAILED;
   }
 }
 
@@ -1254,7 +1254,7 @@ bool DeviceHandlerBase::isAwaitingReply() {
 }
 
 ReturnValue_t DeviceHandlerBase::letChildHandleMessage(CommandMessage* message) {
-  return RETURN_FAILED;
+  return returnvalue::FAILED;
 }
 
 void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t replyId,
@@ -1316,7 +1316,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t r
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                                const uint8_t* data, size_t size) {
   ReturnValue_t result = acceptExternalDeviceCommands();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
@@ -1327,7 +1327,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueue
   } else {
     result = buildCommandFromCommand(actionId, data, size);
   }
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     iter->second.sendReplyTo = commandedBy;
     iter->second.isExecuting = true;
     cookieInfo.pendingCommand = iter;
@@ -1345,7 +1345,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
     if (result == BUSY) {
       /* So we can track misconfigurations */
       printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
-                          HasReturnvaluesIF::RETURN_FAILED, "Busy.");
+                          returnvalue::FAILED, "Busy.");
       /* No need to report this */
       result = NOTHING_TO_SEND;
     }
@@ -1361,7 +1361,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
   if (result == NOTHING_TO_SEND) {
     return;
   }
-  if (result == RETURN_OK) {
+  if (result == returnvalue::OK) {
     DeviceCommandMap::iterator iter = deviceCommandMap.find(deviceCommandId);
     if (iter == deviceCommandMap.end()) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -1378,7 +1378,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
       sprintf(output, "Command 0x%08x is executing", static_cast<unsigned int>(deviceCommandId));
       // so we can track misconfigurations
       printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
-                          HasReturnvaluesIF::RETURN_FAILED, output);
+                          returnvalue::FAILED, output);
 #endif
       // this is an internal command, no need to report a failure here,
       // missed reply will track if a reply is too late, otherwise, it's ok
@@ -1390,7 +1390,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
       cookieInfo.state = COOKIE_WRITE_READY;
     }
   }
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
     triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
   }
 }
@@ -1466,7 +1466,7 @@ ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& lo
     localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
                              new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
@@ -1480,7 +1480,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   if (setStartupImmediately) {
     startTransition(MODE_ON, SUBMODE_NONE);
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
 
 LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
@@ -1518,7 +1518,7 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const ch
   if (errorPrint == nullptr) {
     if (errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
       errorPrint = "Initialization error";
-    } else if (errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+    } else if (errorCode == returnvalue::FAILED) {
       if (errorType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";
       } else {

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -18,7 +18,7 @@
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/parameters/ParameterHelper.h"
 #include "fsfw/power/PowerSwitchIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
@@ -78,7 +78,6 @@ class StorageManagerIF;
  * @ingroup devices
  */
 class DeviceHandlerBase : public DeviceHandlerIF,
-                          public HasReturnvaluesIF,
                           public ExecutableObjectIF,
                           public SystemObject,
                           public HasModesIF,
@@ -145,7 +144,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *   4. Decrements counter for timeout of replies by calling
    *      decrementDeviceReplyMap()
    *   5. Performs FDIR check for failures
-   *   6. If the device mode is MODE_OFF, return RETURN_OK.
+   *   6. If the device mode is MODE_OFF, return returnvalue::OK.
    *      Otherwise, perform the Action property and performs depending
    *      on value specified by input value counter (incremented in PST).
    *      The child class tells base class what to do by setting this value.
@@ -161,7 +160,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *     - GET_READ: Access requested reading data by calling doGetRead()
    *       which calls readReceivedMessage of #communicationInterface
    * @param counter Specifies which Action to perform
-   * @return RETURN_OK for successful execution
+   * @return returnvalue::OK for successful execution
    */
   virtual ReturnValue_t performOperation(uint8_t counter) override;
 
@@ -282,7 +281,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *
    * @param[out] id the device command id that has been built
    * @return
-   *  - @c RETURN_OK to send command after setting #rawPacket and
+   *  - @c returnvalue::OK to send command after setting #rawPacket and
    *    #rawPacketLen.
    *  - @c NOTHING_TO_SEND when no command is to be sent.
    *  - Anything else triggers an even with the returnvalue as a parameter.
@@ -306,7 +305,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *
    * @param[out] id the device command id built
    * @return
-   *    - @c RETURN_OK when a command is to be sent
+   *    - @c returnvalue::OK when a command is to be sent
    *    - @c NOTHING_TO_SEND when no command is to be sent
    *    - Anything else triggers an even with the returnvalue as a parameter
    */
@@ -328,7 +327,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param commandData       Pointer to the data from the direct command
    * @param commandDataLen    Length of commandData
    * @return
-   *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
+   *  - @c returnvalue::OK to send command after #rawPacket and #rawPacketLen
    *       have been set.
    *  - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
    *       be used if no reply is expected
@@ -358,8 +357,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param[out] foundLen length of the data found. Is to be set in function,
    *                       buffer is scanned at previous position + foundLen.
    * @return
-   *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-   *  - @c RETURN_FAILED no reply could be found starting at @c start,
+   *  - @c returnvalue::OK a valid packet was found at @c start, @c foundLen is valid
+   *  - @c returnvalue::FAILED no reply could be found starting at @c start,
    *    implies @c foundLen is not valid, base class will call scanForReply()
    *    again with ++start
    *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
@@ -388,10 +387,10 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param id the id found by scanForReply()
    * @param packet
    * @return
-   *     - @c RETURN_OK when the reply was interpreted.
+   *     - @c returnvalue::OK when the reply was interpreted.
    *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
    *          counter.
-   *     - @c RETURN_FAILED when the reply could not be interpreted,
+   *     - @c returnvalue::FAILED when the reply could not be interpreted,
    *     e.g. logical errors or range violations occurred
    */
   virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) = 0;
@@ -451,8 +450,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
    *                  to provide a pointer to a Countdown object which will signal the timeout
    *                  when expired
-   * @return	- @c RETURN_OK when the command was successfully inserted,
-   *          - @c RETURN_FAILED else.
+   * @return	- @c returnvalue::OK when the command was successfully inserted,
+   *          - @c returnvalue::FAILED else.
    */
   ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
                                            LocalPoolDataSetBase *replyDataSet = nullptr,
@@ -472,8 +471,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
    *                  to provide a pointer to a Countdown object which will signal the timeout
    *                  when expired
-   * @return	- @c RETURN_OK when the command was successfully inserted,
-   *          - @c RETURN_FAILED else.
+   * @return	- @c returnvalue::OK when the command was successfully inserted,
+   *          - @c returnvalue::FAILED else.
    */
   ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
                                  LocalPoolDataSetBase *dataSet = nullptr, size_t replyLen = 0,
@@ -482,8 +481,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /**
    * @brief   A simple command to add a command to the commandList.
    * @param deviceCommand The command to add
-   * @return - @c RETURN_OK when the command was successfully inserted,
-   *         - @c RETURN_FAILED else.
+   * @return - @c returnvalue::OK when the command was successfully inserted,
+   *         - @c returnvalue::FAILED else.
    */
   ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand,
                                    bool useAlternativeReply = false,
@@ -519,8 +518,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param periodic Indicates if the command is periodic (i.e. it is sent
    * by the device repeatedly without request) or not. Default is aperiodic (0).
    * Warning: The setting always overrides the value that was entered in the map.
-   * @return - @c RETURN_OK when the command was successfully inserted,
-   *         - @c RETURN_FAILED else.
+   * @return - @c returnvalue::OK when the command was successfully inserted,
+   *         - @c returnvalue::FAILED else.
    */
   ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply, uint16_t delayCycles,
                                     uint16_t maxDelayCycles, bool periodic = false);
@@ -603,8 +602,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param mode
    * @param submode
    * @return
-   *    - @c RETURN_OK if valid
-   *    - @c RETURN_FAILED if invalid
+   *    - @c returnvalue::OK if valid
+   *    - @c returnvalue::FAILED if invalid
    */
   virtual ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode);
   /**
@@ -623,8 +622,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param[out] switches pointer to an array of switches
    * @param[out] numberOfSwitches length of returned array
    * @return
-   *      - @c RETURN_OK if the parameters were set
-   *      - @c RETURN_FAILED if no switches exist
+   *      - @c returnvalue::OK if the parameters were set
+   *      - @c returnvalue::FAILED if no switches exist
    */
   virtual ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches);
 
@@ -978,7 +977,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * 	- A failure code may be returned if something went fundamentally wrong.
    *
    * @param deviceCommand
-   * @return 	- RETURN_OK if a reply was activated.
+   * @return 	- returnvalue::OK if a reply was activated.
    * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
    * 			  error case as many commands do not expect a reply.
    */
@@ -1005,7 +1004,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *
    * @param[out] id the device command id built
    * @return
-   *    - @c RETURN_OK when a command is to be sent
+   *    - @c returnvalue::OK when a command is to be sent
    *    - not @c NOTHING_TO_SEND when no command is to be sent
    */
   virtual ReturnValue_t buildChildRawCommand();
@@ -1033,7 +1032,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *       by #switches are on
    *  - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by
    *       #switches are off
-   *  - @c PowerSwitchIF::RETURN_FAILED if an error occured
+   *  - @c PowerSwitchIF::returnvalue::FAILED if an error occured
    */
   ReturnValue_t getStateOfSwitches();
 
@@ -1086,7 +1085,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /**
    * Checks if current handler state allows reception of external device commands.
    * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
-   * @return RETURN_OK if commands are accepted, anything else otherwise.
+   * @return returnvalue::OK if commands are accepted, anything else otherwise.
    */
   virtual ReturnValue_t acceptExternalDeviceCommands();
 
@@ -1274,9 +1273,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param[out] data
    * @param[out] len
    * @return
-   *   - @c RETURN_OK @c data is valid
-   *   - @c RETURN_FAILED IPCStore is nullptr
-   *   - the return value from the IPCStore if it was not @c RETURN_OK
+   *   - @c returnvalue::OK @c data is valid
+   *   - @c returnvalue::FAILED IPCStore is nullptr
+   *   - the return value from the IPCStore if it was not @c returnvalue::OK
    */
   ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data, size_t *len);
 
@@ -1306,7 +1305,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param errorPrint
    */
   void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
-                           ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+                           ReturnValue_t errorCode = returnvalue::FAILED,
                            const char *errorPrint = nullptr);
 };
 

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -23,9 +23,9 @@ DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {}
 
 ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
   if (isFdirInActionOrAreWeFaulty(event)) {
-    return RETURN_OK;
+    return returnvalue::OK;
   }
-  ReturnValue_t result = RETURN_FAILED;
+  ReturnValue_t result = returnvalue::FAILED;
   switch (event->getEvent()) {
     case HasModesIF::MODE_TRANSITION_FAILED:
     case HasModesIF::OBJECT_IN_INVALID_MODE:
@@ -48,7 +48,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
       // The two above should never be confirmed.
     case DeviceHandlerIF::DEVICE_MISSED_REPLY:
       result = sendConfirmationRequest(event);
-      if (result == HasReturnvaluesIF::RETURN_OK) {
+      if (result == returnvalue::OK) {
         break;
       }
       // else
@@ -72,7 +72,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
     case PowerSwitchIF::SWITCH_WENT_OFF:
       if (powerConfirmation != MessageQueueIF::NO_QUEUE) {
         result = sendConfirmationRequest(event, powerConfirmation);
-        if (result == RETURN_OK) {
+        if (result == returnvalue::OK) {
           setFdirState(DEVICE_MIGHT_BE_OFF);
         }
       }
@@ -106,9 +106,9 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
       //		break;
     default:
       // We don't know the event, someone else should handle it.
-      return RETURN_FAILED;
+      return returnvalue::FAILED;
   }
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
@@ -162,7 +162,7 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
   ReturnValue_t result = FailureIsolationBase::initialize();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
                   " initialize FailureIsolationBase."
@@ -176,7 +176,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
     powerConfirmation = power->getEventReceptionQueue();
   }
 
-  return RETURN_OK;
+  return returnvalue::OK;
 }
 
 void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {

src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp

@@ -12,11 +12,11 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size
                                                   Endianness streamEndianness) const {
   ReturnValue_t result =
       SerializeAdapter::serialize(&objectId, buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = SerializeAdapter::serialize(&actionId, buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return data->serialize(buffer, size, maxSize, streamEndianness);
@@ -29,11 +29,11 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer, size_t* size,
                                                     Endianness streamEndianness) {
   ReturnValue_t result = SerializeAdapter::deSerialize(&objectId, buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   result = SerializeAdapter::deSerialize(&actionId, buffer, size, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
     return result;
   }
   return data->deSerialize(buffer, size, streamEndianness);