dumb bug

printout tweak
better error printout
2022-09-28 17:00:28 +02:00 · 2022-09-15 13:40:37 +02:00 · 2022-09-15 13:37:10 +02:00 · 2022-09-01 10:51:09 +02:00 · 2022-08-31 22:47:58 +02:00 · 2022-08-31 16:26:18 +02:00
779 changed files with 12181 additions and 8164 deletions
@@ -1,7 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="fsfw-tests_coverage" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
-    <method v="2">
-      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
-    </method>
-  </configuration>
-</component>
@@ -1,7 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="fsfw" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
-    <method v="2">
-      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
-    </method>
-  </configuration>
-</component>
@@ -8,7 +8,32 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

-# [v5.0.0]
+# [v6.0.0]
+
+## Added
+
+- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
+  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
+  types of telemetry.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
+- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
+  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
+  pointer.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
+- Add new `UnsignedByteField` class
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
+
+## 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
+  which also includes a migration guide
+
+# [v5.0.0] 25.07.2022

 ## Changes

@@ -19,16 +44,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Bump C++ required version to C++17. Every project which uses the FSFW and every modern
  compiler supports it
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
-  and mode
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
-  name clashes with Windows defines.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - New CMake option `FSFW_HAL_LINUX_ADD_LIBGPIOD` to specifically exclude `gpiod` code.
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - 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 `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
  - Add helper functions provided by [`cmake-modules`](https://github.com/bilke/cmake-modules)
@@ -46,6 +68,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  creation call. It allows passing context information and an arbitrary user argument into
  the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
+- Internal API change: Moved the `fsfw_hal` to the `src` folder and integration and internal
+  tests part of `fsfw_tests` to `src`. Unittests are now in a dedicated folder called `unittests`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/653

 ### Task Module Refactoring

@@ -120,6 +145,8 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593

 ## Additions

+- New constructor for PoolEntry which allows to simply specify the length of the pool entry.
+  This is also the new default constructor for scalar value with 0 as an initial value
 - Added options for CI/CD builds: `FSFW_CICD_BUILD`. This allows the source code to know
  whether it is running in CI/CD
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/623
@@ -139,7 +166,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
  Easiest solution for now: Keep this option OFF by default.
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
  inside `fsfw/version.h`
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
@@ -154,6 +180,17 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries

+## HAL
+
+- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
+  lot more sense because each ComIF should be responsible for one SPI bus.
+- SPI: Move the empty transfer to update the line polarity to separate function. This means
+  it is not automatically called when calling the setter function for SPI speed and mode.
+  The user should call this function after locking the CS mutex if multiple SPI devices with
+  differing speeds and modes are attached to one bus.
+- SPI: Getter functions for SPI speed and mode.
+- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
+
 ## Fixed

 - TCP TMTC Server: `MutexGuard` was not created properly in
@@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################

-set(FSFW_VERSION_IF_GIT_FAILS 4)
+set(FSFW_VERSION_IF_GIT_FAILS 5)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)

@@ -67,6 +67,7 @@ endif()
 set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")

 set(FSFW_ETL_LIB_NAME etl)
+set(FSFW_ETL_LINK_TARGET etl::etl)
 set(FSFW_ETL_LIB_MAJOR_VERSION
    20
    CACHE STRING "ETL library major version requirement")
@@ -103,11 +104,11 @@ if(FSFW_GENERATE_SECTIONS)
  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()

-option(FSFW_BUILD_UNITTESTS
-       "Build unittest binary in addition to static library" OFF)
+option(FSFW_BUILD_TESTS "Build unittest binary in addition to static library"
+       OFF)
 option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
-if(FSFW_BUILD_UNITTESTS)
+if(FSFW_BUILD_TESTS)
  option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()

@@ -117,6 +118,12 @@ option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
 option(FSFW_ADD_UNITTESTS "Add regular unittests. Requires Catch2" OFF)
 option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)

+if(UNIX)
+  option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add Linux peripheral drivers"
+         OFF)
+  option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Attempt to add Linux GPIOD drivers" OFF)
+endif()
+
 # Optional sources
 option(FSFW_ADD_PUS "Compile with PUS sources" ON)
 option(FSFW_ADD_MONITORING "Compile with monitoring components" ON)
@@ -139,7 +146,7 @@ if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
                                                TRUE)
 endif()

-if(FSFW_BUILD_UNITTESTS)
+if(FSFW_BUILD_TESTS)
  message(
    STATUS
      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
@@ -162,10 +169,9 @@ if(FSFW_BUILD_UNITTESTS)
    list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
  endif()

-  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
-                 tests/TestsConfig.h)
+  set(FSFW_CONFIG_PATH unittests/testcfg)
+  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)

  project(${FSFW_TEST_TGT} CXX C)
  add_executable(${FSFW_TEST_TGT})
@@ -183,15 +189,18 @@ if(FSFW_BUILD_UNITTESTS)
  endif()
 endif()

-message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
+message(
+  STATUS
+    "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}"
+)

 # Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
  message(
    STATUS
-      "No ETL installation was found with find_package. Installing and providing "
+      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
      "etl with FindPackage")
  include(FetchContent)

@@ -281,16 +290,15 @@ message(
 )

 add_subdirectory(src)
-add_subdirectory(tests)
-if(FSFW_ADD_HAL)
-  add_subdirectory(hal)
-endif()
 add_subdirectory(contrib)
+if(FSFW_BUILD_TESTS)
+  add_subdirectory(unittests)
+endif()
 if(FSFW_BUILD_DOCS)
  add_subdirectory(docs)
 endif()

-if(FSFW_BUILD_UNITTESTS)
+if(FSFW_BUILD_TESTS)
  if(FSFW_TESTS_GEN_COV)
    if(CMAKE_COMPILER_IS_GNUCXX)
      include(CodeCoverage)
@@ -447,8 +455,8 @@ target_include_directories(
 target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
                                                ${COMPILER_FLAGS})

-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-                                               ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})

 string(
  CONCAT
@@ -132,14 +132,14 @@ You can use the following commands inside the `fsfw` folder to set up the build

 ```sh
 mkdir build-tests && cd build-tests
-cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
+cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```

 You can also use `-DFSFW_OSAL=linux` on Linux systems.

 Coverage data in HTML format can be generated using the `CodeCoverage`
 [CMake module](https://github.com/bilke/cmake-modules/tree/master).
-To build the unittests, run them and then generare the coverage data in this format,
+To build the unittests, run them and then generate the coverage data in this format,
 the following command can be used inside the build directory after the build system was set up

 ```sh
@@ -188,7 +188,10 @@ and open the documentation conveniently. Try `helper.py -h for more information.

 The formatting is done by the `clang-format` tool. The configuration is contained within the
 `.clang-format` file in the repository root. As long as `clang-format` is installed, you
-can run the `apply-clang-format.sh` helper script to format all source files consistently.
+can run the `auto-format.sh` helper script to format all source files consistently. Furthermore cmake-format is required to format CMake files which can be installed with:
+````sh
+sudo pip install cmakelang
+````

 ## Index

@@ -1,9 +1,9 @@
 pipeline {
    environment {
-        BUILDDIR = 'build-tests'
+        BUILDDIR = 'cmake-build-tests'
    }
    agent {
-        docker { image 'fsfw-ci:d2'}
+        docker { image 'fsfw-ci:d3'}
    }
    stages {
        stage('Clean') {
@@ -14,7 +14,7 @@ pipeline {
        stage('Configure') {
            steps {
                dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
                }
            }
        }
@@ -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.
@@ -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);
 	}
@@ -3,7 +3,7 @@
 Returnvalue API
 ==================

-.. doxygenfile:: HasReturnvaluesIF.h
+.. doxygenfile:: returnvalue.h

 .. _fwclassids:

@@ -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;
 	}
@@ -106,7 +106,7 @@ You can use the following commands inside the ``fsfw`` folder to set up the buil
 .. code-block:: console

   mkdir build-tests && cd build-tests
-   cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host ..
+   cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host ..


 You can also use ``-DFSFW_OSAL=linux`` on Linux systems.
@@ -18,7 +18,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.
@@ -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);
 		}
@@ -1,48 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-
-# Can also be changed by upper CMakeLists.txt file
-find_library(LIB_FSFW_NAME fsfw REQUIRED)
-
-option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Requires gpiod library" OFF)
-# On by default for now because I did not have an issue including and compiling those files
-# and libraries on a Desktop Linux system and the primary target of the FSFW is still embedded
-# Linux. The only exception from this is the gpiod library which requires a dedicated installation,
-# but CMake is able to determine whether this library is installed with find_library.
-option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add peripheral drivers for embedded Linux" ON)
-option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Target implements libgpiod" ON)
-
-option(FSFW_HAL_ADD_RASPBERRY_PI "Add Raspberry Pi specific code to the sources" OFF)
-option(FSFW_HAL_ADD_STM32H7 "Add the STM32H7 HAL to the sources" OFF)
-option(FSFW_HAL_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
-
-set(LINUX_HAL_PATH_NAME linux)
-set(STM32H7_PATH_NAME stm32h7)
-
-add_subdirectory(src)
-
-foreach(INCLUDE_PATH ${FSFW_HAL_ADDITIONAL_INC_PATHS})
-    if(IS_ABSOLUTE ${INCLUDE_PATH})
-        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-    else()
-        get_filename_component(CURR_ABS_INC_PATH
-            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
-    endif()
-
-    if(CMAKE_VERBOSE)
-        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-    endif()
-
-    list(APPEND FSFW_HAL_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
-endforeach()
-
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_HAL_ADD_INC_PATHS_ABS}
-)
-
-target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_HAL_DEFINES}
-)
-
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_HAL_LINK_LIBS}
-)
@@ -1,9 +0,0 @@
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-target_include_directories(${LIB_FSFW_NAME} INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-add_subdirectory(fsfw_hal)
@@ -1,3 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    GpioCookie.cpp
-)
@@ -1,5 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    GyroL3GD20Handler.cpp
-    MgmRM3100Handler.cpp
-    MgmLIS3MDLHandler.cpp
-)
@@ -1,25 +0,0 @@
-if(FSFW_HAL_ADD_RASPBERRY_PI)
-    add_subdirectory(rpi)
-endif()
-
-target_sources(${LIB_FSFW_NAME} PRIVATE
-	UnixFileGuard.cpp
-	CommandExecutor.cpp
-	utility.cpp
-)
-
-if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
-if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
-	add_subdirectory(gpio)
-endif()
-	add_subdirectory(uart)
-	# Adding those does not really make sense on Apple systems which
-	# are generally host systems. It won't even compile as the headers
-	# are missing
-	if(NOT APPLE)
-		add_subdirectory(i2c)
-		add_subdirectory(spi)
-	endif()
-endif()
-
-add_subdirectory(uio)
@@ -1,16 +0,0 @@
-# This abstraction layer requires the gpiod library. You can install this library
-# with "sudo apt-get install -y libgpiod-dev". If you are cross-compiling, you need
-# to install the package before syncing the sysroot to your host computer.
-find_library(LIB_GPIO gpiod)
-
-if(${LIB_GPIO} MATCHES LIB_GPIO-NOTFOUND)
-    message(STATUS "gpiod library not found, not linking against it")
-else()
-    target_sources(${LIB_FSFW_NAME} PRIVATE
-        LinuxLibgpioIF.cpp
-    )
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-        ${LIB_GPIO}
-    )
-endif()
-
@@ -1,8 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-    I2cComIF.cpp
-    I2cCookie.cpp
-)
-
-
-
-
@@ -1,3 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    GpioRPi.cpp
-)
@@ -1,8 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-    SpiComIF.cpp
-    SpiCookie.cpp
-)
-
-
-
-
@@ -1,4 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-	UartComIF.cpp
-	UartCookie.cpp
-)
@@ -1,3 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC
-	UioMapper.cpp
-)
@@ -1,3 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    GyroL3GD20H.cpp
-)
@@ -1,3 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    gpio.cpp
-)
@@ -1,2 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-)
@@ -1,9 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-    spiCore.cpp
-    spiDefinitions.cpp
-    spiInterrupts.cpp
-    mspInit.cpp
-    SpiCookie.cpp
-    SpiComIF.cpp
-    stm32h743zi.cpp
-)
@@ -1,2 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-)
@@ -35,8 +35,8 @@ void Factory::produceFsfwObjects(void) {
 }

 void Factory::setStaticFrameworkObjectIds() {
-	PusServiceBase::packetSource = objects::NO_OBJECT;
-	PusServiceBase::packetDestination = objects::NO_OBJECT;
+	PusServiceBase::PUS_DISTRIBUTOR = objects::NO_OBJECT;
+	PusServiceBase::PACKET_DESTINATION = objects::NO_OBJECT;

 	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
 	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
@@ -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;
 	}
 }

@@ -1,7 +1,7 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_

-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>

 class FixedTimeslotTaskIF;

@@ -3,6 +3,11 @@ if [[ ! -f README.md ]]; then
  cd ..
 fi

+folder_list=(
+  "./src"
+  "./unittests"
+)
+
 cmake_fmt="cmake-format"
 file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
@@ -15,9 +20,10 @@ fi
 cpp_format="clang-format"
 file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
 if command -v ${cpp_format} &> /dev/null; then
-  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./tests ${file_selectors} | xargs ${cpp_format} --style=file -i
+  for dir in ${folder_list[@]}; do
+    echo "Auto-formatting ${dir} recursively"
+    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
+  done
 else
  echo "No ${cpp_format} tool found, not formatting C++/C files"
 fi
@@ -13,7 +13,7 @@ from shutil import which
 from typing import List


-UNITTEST_FOLDER_NAME = "build-tests"
+UNITTEST_FOLDER_NAME = "cmake-build-tests"
 DOCS_FOLDER_NAME = "build-docs"


@@ -48,6 +48,20 @@ def main():
        action="store_true",
        help="Run valgrind on generated test binary",
    )
+    parser.add_argument(
+        "-g",
+        "--generators",
+        default = "Ninja",
+        action="store",
+        help="CMake generators",
+    )
+    parser.add_argument(
+        "-w",
+        "--windows",
+        default=False,
+        action="store_true",
+        help="Run on windows",
+    )

    args = parser.parse_args()
    if args.all:
@@ -115,14 +129,14 @@ def handle_tests_type(args, build_dir_list: list):
    if args.create:
        if os.path.exists(UNITTEST_FOLDER_NAME):
            shutil.rmtree(UNITTEST_FOLDER_NAME)
-        create_tests_build_cfg()
+        create_tests_build_cfg(args)
        build_directory = UNITTEST_FOLDER_NAME
    elif len(build_dir_list) == 0:
        print(
            "No valid CMake tests build directory found. "
            "Trying to set up test build system"
        )
-        create_tests_build_cfg()
+        create_tests_build_cfg(args)
        build_directory = UNITTEST_FOLDER_NAME
    elif len(build_dir_list) == 1:
        build_directory = build_dir_list[0]
@@ -147,10 +161,15 @@ def handle_tests_type(args, build_dir_list: list):
        os.chdir("..")


-def create_tests_build_cfg():
+def create_tests_build_cfg(args):
    os.mkdir(UNITTEST_FOLDER_NAME)
    os.chdir(UNITTEST_FOLDER_NAME)
-    cmd_runner("cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..")
+    if args.windows:
+        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON \
+        -DGCOVR_PATH="py -m gcovr" ..'
+    else:
+        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON ..'
+    cmd_runner(cmake_cmd)
    os.chdir("..")


@@ -4,3 +4,8 @@ target_include_directories(${LIB_FSFW_NAME}
                           INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

 add_subdirectory(fsfw)
+if(FSFW_ADD_HAL)
+  add_subdirectory(fsfw_hal)
+endif()
+
+add_subdirectory(fsfw_tests)
@@ -6,13 +6,13 @@
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
    : owner(setOwner), queueToUse(useThisQueue) {}

-ActionHelper::~ActionHelper() {}
+ActionHelper::~ActionHelper() = default;

 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
  if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
    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,
@@ -59,10 +59,10 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }

 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                    store_address_t dataAddress) {
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
  size_t size = 0;
  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  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;
@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_

-#include "../ipc/MessageQueueIF.h"
-#include "../serialize/SerializeIF.h"
 #include "ActionMessage.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/serialize/SerializeIF.h"
 /**
 * @brief Action Helper is a helper class which handles action messages
 *
@@ -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);
@@ -2,9 +2,9 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"

-ActionMessage::ActionMessage() {}
+ActionMessage::ActionMessage() = default;

-ActionMessage::~ActionMessage() {}
+ActionMessage::~ActionMessage() = default;

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

 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner)
-    : owner(setOwner), queueToUse(NULL), ipcStore(NULL), commandCount(0), lastTarget(0) {}
+    : owner(setOwner), queueToUse(nullptr), ipcStore(nullptr), commandCount(0), lastTarget(0) {}

-CommandActionHelper::~CommandActionHelper() {}
+CommandActionHelper::~CommandActionHelper() = default;

 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                 SerializeIF *data) {
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
    return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
  }
  store_address_t storeId;
  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);
@@ -29,16 +29,13 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId

 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                 const uint8_t *data, uint32_t size) {
-  //    if (commandCount != 0) {
-  //        return CommandsFunctionsIF::ALREADY_COMMANDING;
-  //    }
-  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == NULL) {
+  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == nullptr) {
    return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
  }
  store_address_t storeId;
  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);
@@ -49,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;
@@ -59,55 +56,55 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI

 ReturnValue_t CommandActionHelper::initialize() {
  ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-  if (ipcStore == NULL) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+  if (ipcStore == nullptr) {
+    return returnvalue::FAILED;
  }

  queueToUse = owner->getCommandQueuePtr();
-  if (queueToUse == NULL) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+  if (queueToUse == nullptr) {
+    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;
  }
 }

 uint8_t CommandActionHelper::getCommandCount() const { return commandCount; }

 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-  const uint8_t *data = NULL;
+  const uint8_t *data = nullptr;
  size_t size = 0;
  ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return;
  }
  owner->dataReceived(actionId, data, size);
@@ -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"

@@ -14,14 +14,14 @@ class CommandActionHelper {
  friend class CommandsActionsIF;

 public:
-  CommandActionHelper(CommandsActionsIF* owner);
+  explicit CommandActionHelper(CommandsActionsIF* owner);
  virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
-                              uint32_t size);
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
+                              const uint8_t* data = nullptr, uint32_t size = 0);
  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
  ReturnValue_t initialize();
  ReturnValue_t handleReply(CommandMessage* reply);
-  uint8_t getCommandCount() const;
+  [[nodiscard]] uint8_t getCommandCount() const;

 private:
  CommandsActionsIF* owner;
@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
 #define FSFW_ACTION_COMMANDSACTIONSIF_H_

-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "CommandActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/returnvalue.h"

 /**
 * Interface to separate commanding actions of other objects.
@@ -21,7 +21,7 @@ class CommandsActionsIF {
  static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
  static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
  static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-  virtual ~CommandsActionsIF() {}
+  virtual ~CommandsActionsIF() = default;
  virtual MessageQueueIF* getCommandQueuePtr() = 0;

 protected:
@@ -1,11 +1,11 @@
 #ifndef FSFW_ACTION_HASACTIONSIF_H_
 #define FSFW_ACTION_HASACTIONSIF_H_

-#include "../ipc/MessageQueueIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/returnvalue.h"

 /**
 * @brief
@@ -40,12 +40,12 @@ class HasActionsIF {
  static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
  static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
  static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-  virtual ~HasActionsIF() {}
+  virtual ~HasActionsIF() = default;
  /**
   * Function to get the MessageQueueId_t of the implementing object
   * @return MessageQueueId_t of the object
   */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
  /**
   * Execute or initialize the execution of a certain function.
   * The ActionHelpers will execute this function and behave differently
@@ -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;
@@ -3,13 +3,13 @@
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
    : ActionHelper(setOwner, useThisQueue), isExecuting(false) {}

-SimpleActionHelper::~SimpleActionHelper() {}
+SimpleActionHelper::~SimpleActionHelper() = default;

 void SimpleActionHelper::step(ReturnValue_t result) {
  // STEP_OFFESET is subtracted to compensate for adding offset in base
  // method, which is not necessary here.
  ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction, result);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    resetHelper();
  }
 }
@@ -38,10 +38,10 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::IS_BUSY);
    queueToUse->sendMessage(commandedBy, &reply);
  }
-  const uint8_t* dataPtr = NULL;
+  const uint8_t* dataPtr = nullptr;
  size_t size = 0;
  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  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:
@@ -11,15 +11,15 @@
 class SimpleActionHelper : public ActionHelper {
 public:
  SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-  virtual ~SimpleActionHelper();
-  void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-  void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+  ~SimpleActionHelper() override;
+  void step(ReturnValue_t result = returnvalue::OK);
+  void finish(ReturnValue_t result = returnvalue::OK);
  ReturnValue_t reportData(SerializeIF* data);

 protected:
  void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-                        store_address_t dataAddress);
-  virtual void resetHelper();
+                        store_address_t dataAddress) override;
+  void resetHelper() override;

 private:
  bool isExecuting;
@@ -28,4 +28,4 @@ class SimpleActionHelper : public ActionHelper {
  uint8_t stepCount = 0;
 };

-#endif /* SIMPLEACTIONHELPER_H_ */
+#endif /* FSFW_ACTION_SIMPLEACTIONHELPER_H_ */
@@ -1,57 +0,0 @@
-#include "fsfw/cfdp/CFDPHandler.h"
-
-#include "fsfw/cfdp/CFDPMessage.h"
-#include "fsfw/ipc/CommandMessage.h"
-#include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/storagemanager/storeAddress.h"
-#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
-
-object_id_t CFDPHandler::packetSource = 0;
-object_id_t CFDPHandler::packetDestination = 0;
-
-CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist)
-    : SystemObject(setObjectId) {
-  requestQueue = QueueFactory::instance()->createMessageQueue(CFDP_HANDLER_MAX_RECEPTION);
-  distributor = dist;
-}
-
-CFDPHandler::~CFDPHandler() {}
-
-ReturnValue_t CFDPHandler::initialize() {
-  ReturnValue_t result = SystemObject::initialize();
-  if (result != RETURN_OK) {
-    return result;
-  }
-  this->distributor->registerHandler(this);
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::debug << "CFDPHandler::handleRequest" << std::endl;
-#else
-  sif::printDebug("CFDPHandler::handleRequest\n");
-#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif
-
-  // TODO read out packet from store using storeId
-
-  return RETURN_OK;
-}
-
-ReturnValue_t CFDPHandler::performOperation(uint8_t opCode) {
-  ReturnValue_t status = RETURN_OK;
-  CommandMessage currentMessage;
-  for (status = this->requestQueue->receiveMessage(&currentMessage); status == RETURN_OK;
-       status = this->requestQueue->receiveMessage(&currentMessage)) {
-    store_address_t storeId = CFDPMessage::getStoreId(&currentMessage);
-    this->handleRequest(storeId);
-  }
-  return RETURN_OK;
-}
-
-uint16_t CFDPHandler::getIdentifier() { return 0; }
-
-MessageQueueId_t CFDPHandler::getRequestQueue() { return this->requestQueue->getId(); }
@@ -1,17 +0,0 @@
-#include "CFDPMessage.h"
-
-CFDPMessage::CFDPMessage() {}
-
-CFDPMessage::~CFDPMessage() {}
-
-void CFDPMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
-  message->setParameter(cfdpPacket.raw);
-}
-
-store_address_t CFDPMessage::getStoreId(const CommandMessage *message) {
-  store_address_t storeAddressCFDPPacket;
-  storeAddressCFDPPacket = message->getParameter();
-  return storeAddressCFDPPacket;
-}
-
-void CFDPMessage::clear(CommandMessage *message) {}
@@ -1,4 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE CFDPHandler.cpp CFDPMessage.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE CfdpHandler.cpp CfdpMessage.cpp)

 add_subdirectory(pdu)
 add_subdirectory(tlv)
@@ -0,0 +1,58 @@
+#include "fsfw/cfdp/CfdpHandler.h"
+
+#include "fsfw/cfdp/CfdpMessage.h"
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/storagemanager/storeAddress.h"
+#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+
+object_id_t CfdpHandler::packetSource = 0;
+object_id_t CfdpHandler::packetDestination = 0;
+
+CfdpHandler::CfdpHandler(object_id_t setObjectId, CFDPDistributor* dist)
+    : SystemObject(setObjectId) {
+  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  requestQueue = QueueFactory::instance()->createMessageQueue(
+      CFDP_HANDLER_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  distributor = dist;
+}
+
+CfdpHandler::~CfdpHandler() = default;
+
+ReturnValue_t CfdpHandler::initialize() {
+  ReturnValue_t result = SystemObject::initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  this->distributor->registerHandler(this);
+  return returnvalue::OK;
+}
+
+ReturnValue_t CfdpHandler::handleRequest(store_address_t storeId) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::debug << "CFDPHandler::handleRequest" << std::endl;
+#else
+  sif::printDebug("CFDPHandler::handleRequest\n");
+#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif
+
+  // TODO read out packet from store using storeId
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t CfdpHandler::performOperation(uint8_t opCode) {
+  ReturnValue_t status = returnvalue::OK;
+  CommandMessage currentMessage;
+  for (status = this->requestQueue->receiveMessage(&currentMessage); status == returnvalue::OK;
+       status = this->requestQueue->receiveMessage(&currentMessage)) {
+    store_address_t storeId = CfdpMessage::getStoreId(&currentMessage);
+    this->handleRequest(storeId);
+  }
+  return returnvalue::OK;
+}
+
+uint16_t CfdpHandler::getIdentifier() { return 0; }
+
+MessageQueueId_t CfdpHandler::getRequestQueue() { return this->requestQueue->getId(); }
@@ -3,7 +3,7 @@

 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tcdistribution/CFDPDistributor.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
@@ -12,18 +12,15 @@ namespace Factory {
 void setStaticFrameworkObjectIds();
 }

-class CFDPHandler : public ExecutableObjectIF,
-                    public AcceptsTelecommandsIF,
-                    public SystemObject,
-                    public HasReturnvaluesIF {
+class CfdpHandler : public ExecutableObjectIF, public AcceptsTelecommandsIF, public SystemObject {
  friend void(Factory::setStaticFrameworkObjectIds)();

 public:
-  CFDPHandler(object_id_t setObjectId, CFDPDistributor* distributor);
+  CfdpHandler(object_id_t setObjectId, CFDPDistributor* distributor);
  /**
   * The destructor is empty.
   */
-  virtual ~CFDPHandler();
+  virtual ~CfdpHandler();

  virtual ReturnValue_t handleRequest(store_address_t storeId);

@@ -45,7 +42,7 @@ class CFDPHandler : public ExecutableObjectIF,
   * The current CFDP packet to be processed.
   * It is deleted after handleRequest was executed.
   */
-  CFDPPacketStored currentPacket;
+  CfdpPacketStored currentPacket;

  static object_id_t packetSource;

@@ -0,0 +1,17 @@
+#include "CfdpMessage.h"
+
+CfdpMessage::CfdpMessage() = default;
+
+CfdpMessage::~CfdpMessage() = default;
+
+void CfdpMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
+  message->setParameter(cfdpPacket.raw);
+}
+
+store_address_t CfdpMessage::getStoreId(const CommandMessage *message) {
+  store_address_t storeId;
+  storeId = static_cast<store_address_t>(message->getParameter());
+  return storeId;
+}
+
+void CfdpMessage::clear(CommandMessage *message) {}
@@ -5,14 +5,14 @@
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"

-class CFDPMessage {
+class CfdpMessage {
 private:
-  CFDPMessage();
+  CfdpMessage();

 public:
  static const uint8_t MESSAGE_ID = messagetypes::CFDP;

-  virtual ~CFDPMessage();
+  virtual ~CfdpMessage();
  static void setCommand(CommandMessage* message, store_address_t cfdpPacket);

  static store_address_t getStoreId(const CommandMessage* message);
@@ -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;
  }

  bool isLargeFile() const { return largeFile; }
@@ -7,7 +7,7 @@
 #include <cstdint>

 #include "fsfw/returnvalues/FwClassIds.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/returnvalue.h"

 namespace cfdp {

@@ -15,28 +15,24 @@ static constexpr uint8_t VERSION_BITS = 0b00100000;

 static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP;

-static constexpr ReturnValue_t INVALID_TLV_TYPE =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 1);
-static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 2);
-static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 3);
+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 =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 4);
+    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 =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 5);
-static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 6);
+    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 =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 6);
+    returnvalue::makeCode(CFDP_CLASS_ID, 6);
 static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 8);
+    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 =
-    HasReturnvaluesIF::makeReturnCode(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/
@@ -5,7 +5,7 @@ AckPduDeserializer::AckPduDeserializer(const uint8_t* pduBuf, size_t maxSize, Ac

 ReturnValue_t AckPduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
@@ -15,7 +15,7 @@ ReturnValue_t AckPduDeserializer::parseData() {
  if (not checkAndSetCodes(rawPtr[currentIdx], 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) {
@@ -11,7 +11,7 @@ ReturnValue_t AckPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
                                          Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  cfdp::FileDirectives ackedDirective = ackInfo.getAckedDirective();
@@ -21,7 +21,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;
@@ -32,5 +32,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;
 }
@@ -8,7 +8,7 @@ EofPduDeserializer::EofPduDeserializer(const uint8_t* pduBuf, size_t maxSize, Eo

 ReturnValue_t EofPduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::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);
  }
@@ -16,7 +16,7 @@ ReturnValue_t EofPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
                                          Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (*size + 1 > maxSize) {
@@ -27,7 +27,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()) {
@@ -6,7 +6,7 @@ FileDataDeserializer::FileDataDeserializer(const uint8_t* pduBuf, size_t maxSize

 ReturnValue_t FileDataDeserializer::parseData() {
  ReturnValue_t result = HeaderDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = HeaderDeserializer::getHeaderSize();
@@ -32,13 +32,13 @@ ReturnValue_t FileDataDeserializer::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 FileDataDeserializer::getEndianness() const { return endianness; }
@@ -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 {
@@ -17,7 +17,7 @@ void FileDataSerializer::update() {
 ReturnValue_t FileDataSerializer::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                            Endianness streamEndianness) const {
  ReturnValue_t result = HeaderSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (*size + this->getSerializedSize() > maxSize) {
@@ -36,7 +36,7 @@ ReturnValue_t FileDataSerializer::serialize(uint8_t** buffer, size_t* size, size
  }
  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;
@@ -47,7 +47,7 @@ ReturnValue_t FileDataSerializer::serialize(uint8_t** buffer, size_t* size, size
  std::memcpy(*buffer, readOnlyPtr, fileSize);
  *buffer += fileSize;
  *size += fileSize;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 size_t FileDataSerializer::getSerializedSize() const {
@@ -7,7 +7,7 @@ cfdp::FileDirectives FileDirectiveDeserializer::getFileDirective() const { retur

 ReturnValue_t FileDirectiveDeserializer::parseData() {
  ReturnValue_t result = HeaderDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (this->getPduDataFieldLen() < 1) {
@@ -21,7 +21,7 @@ ReturnValue_t FileDirectiveDeserializer::parseData() {
    return cfdp::INVALID_DIRECTIVE_FIELDS;
  }
  setFileDirective(static_cast<cfdp::FileDirectives>(rawPtr[currentIdx]));
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 size_t FileDirectiveDeserializer::getHeaderSize() const {
@@ -13,13 +13,13 @@ size_t FileDirectiveSerializer::getSerializedSize() const {
 ReturnValue_t FileDirectiveSerializer::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 (FileDirectiveSerializer::getWholePduSize() > maxSize) {
    return BUFFER_TOO_SHORT;
  }
  ReturnValue_t result = HeaderSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }

@@ -29,7 +29,7 @@ ReturnValue_t FileDirectiveSerializer::serialize(uint8_t **buffer, size_t *size,
  **buffer = directiveCode;
  *buffer += 1;
  *size += 1;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 void FileDirectiveSerializer::setDirectiveDataFieldLen(size_t len) {
@@ -46,14 +46,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) {
@@ -62,7 +62,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) {
@@ -71,10 +71,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; }
@@ -6,7 +6,7 @@ FinishPduDeserializer::FinishPduDeserializer(const uint8_t* pduBuf, size_t maxSi

 ReturnValue_t FinishPduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = FileDirectiveDeserializer::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 {
@@ -17,7 +17,7 @@ ReturnValue_t FinishPduSerializer::serialize(uint8_t **buffer, size_t *size, siz
                                             Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (*size + 1 >= maxSize) {
@@ -34,13 +34,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;
@@ -18,7 +18,7 @@ ReturnValue_t HeaderDeserializer::setData(uint8_t *dataPtr, size_t maxSize, void
  if (dataPtr == nullptr) {
    // Allowed for now
    this->fixedHeader = nullptr;
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
  }
  this->fixedHeader = reinterpret_cast<PduHeaderFixedStruct *>(const_cast<uint8_t *>(dataPtr));
  sourceIdRaw = static_cast<uint8_t *>(&fixedHeader->variableFieldsStart);
@@ -27,7 +27,7 @@ ReturnValue_t HeaderDeserializer::setData(uint8_t *dataPtr, size_t maxSize, void
  seqNumRaw = static_cast<uint8_t *>(sourceIdRaw) + static_cast<uint8_t>(widthEntityIds);
  destIdRaw = static_cast<uint8_t *>(seqNumRaw) + static_cast<uint8_t>(widthSeqNum);
  this->maxSize = maxSize;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 size_t HeaderDeserializer::getHeaderSize() const {
@@ -36,8 +36,8 @@ class HeaderDeserializer : 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();
@@ -61,7 +61,7 @@ class HeaderDeserializer : 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;

  /**
   * Can also be used to reset the pointer to a nullptr, but the getter functions will not
@@ -15,7 +15,7 @@ HeaderSerializer::HeaderSerializer(PduConfig &pduConf, cfdp::PduType pduType,
 ReturnValue_t HeaderSerializer::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 (maxSize < this->getSerializedSize()) {
    return BUFFER_TOO_SHORT;
@@ -32,19 +32,19 @@ ReturnValue_t HeaderSerializer::serialize(uint8_t **buffer, size_t *size, size_t
  *buffer += 1;
  *size += 4;
  ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = pduConf.seqNum.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  result = pduConf.destId.serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }

-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 size_t HeaderSerializer::getSerializedSize() const {
@@ -55,7 +55,7 @@ size_t HeaderSerializer::getSerializedSize() const {
 ReturnValue_t HeaderSerializer::deSerialize(const uint8_t **buffer, size_t *size,
                                            Endianness streamEndianness) {
  // We could implement this, but I prefer dedicated classes
-  return HasReturnvaluesIF::RETURN_FAILED;
+  return returnvalue::FAILED;
 }

 size_t HeaderSerializer::getWholePduSize() const {
@@ -6,7 +6,7 @@ KeepAlivePduDeserializer::KeepAlivePduDeserializer(const uint8_t* pduBuf, size_t

 ReturnValue_t KeepAlivePduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
@@ -19,7 +19,7 @@ ReturnValue_t KeepAlivePduSerializer::serialize(uint8_t **buffer, size_t *size,
                                                Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::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);
@@ -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 this->optionsArray == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
+    return returnvalue::FAILED;
  }
  *optionsArray = this->optionsArray;
  if (optionsLen != nullptr) {
@@ -48,7 +48,7 @@ ReturnValue_t MetadataInfo::getOptions(cfdp::Tlv*** optionsArray, size_t* option
  if (maxOptsLen != nullptr) {
    *maxOptsLen = this->maxOptionsLen;
  }
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 bool MetadataInfo::hasOptions() const {
@@ -6,7 +6,7 @@ MetadataPduDeserializer::MetadataPduDeserializer(const uint8_t* pduBuf, size_t m

 ReturnValue_t MetadataPduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
@@ -21,15 +21,15 @@ ReturnValue_t MetadataPduDeserializer::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;
  }

@@ -47,7 +47,7 @@ ReturnValue_t MetadataPduDeserializer::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++;
@@ -17,7 +17,7 @@ ReturnValue_t MetadataPduSerializer::serialize(uint8_t **buffer, size_t *size, s
                                               Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (*size + 1 >= maxSize) {
@@ -27,15 +27,15 @@ ReturnValue_t MetadataPduSerializer::serialize(uint8_t **buffer, size_t *size, s
  *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;
  }

@@ -45,7 +45,7 @@ ReturnValue_t MetadataPduSerializer::serialize(uint8_t **buffer, size_t *size, s
    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;
      }
    }
@@ -5,7 +5,7 @@ NakPduDeserializer::NakPduDeserializer(const uint8_t* pduBuf, size_t maxSize, Na

 ReturnValue_t NakPduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = FileDirectiveDeserializer::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++;
@@ -17,15 +17,15 @@ ReturnValue_t NakPduSerializer::serialize(uint8_t **buffer, size_t *size, size_t
                                          Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::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()) {
@@ -34,11 +34,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;
      }
    }
@@ -9,7 +9,7 @@ cfdp::PromptResponseRequired PromptPduDeserializer::getPromptResponseRequired()

 ReturnValue_t PromptPduDeserializer::parseData() {
  ReturnValue_t result = FileDirectiveDeserializer::parseData();
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  size_t currentIdx = FileDirectiveDeserializer::getHeaderSize();
@@ -17,5 +17,5 @@ ReturnValue_t PromptPduDeserializer::parseData() {
    return SerializeIF::STREAM_TOO_SHORT;
  }
  responseRequired = static_cast<cfdp::PromptResponseRequired>((rawPtr[currentIdx] >> 7) & 0x01);
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }
@@ -13,7 +13,7 @@ ReturnValue_t PromptPduSerializer::serialize(uint8_t **buffer, size_t *size, siz
                                             Endianness streamEndianness) const {
  ReturnValue_t result =
      FileDirectiveSerializer::serialize(buffer, size, maxSize, streamEndianness);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
  if (*size + 1 > maxSize) {
@@ -6,7 +6,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;
@@ -25,21 +25,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;
@@ -49,7 +49,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 {
@@ -77,7 +77,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);
@@ -86,7 +86,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;
    }
  }
 }
@@ -105,7 +105,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);
@@ -114,7 +114,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;
    }
  }
 }
@@ -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::FaultHandlerCode>(**buffer & 0x0f);
  *buffer += 1;
  *size += 1;
-  return HasReturnvaluesIF::RETURN_OK;
+  return returnvalue::OK;
 }

 cfdp::TlvTypes FaultHandlerOverrideTlv::getType() const { return cfdp::TlvTypes::FAULT_HANDLER; }
@@ -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);
  }
@@ -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);
 }
@@ -73,7 +73,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;
@@ -90,13 +90,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;
@@ -114,7 +114,7 @@ class FilestoreTlvBase : public TlvIF {
    if (remainingLength == 0) {
      return SerializeIF::STREAM_TOO_SHORT;
    }
-    return HasReturnvaluesIF::RETURN_OK;
+    return returnvalue::OK;
  }

  bool requiresSecondFileName() const {
@@ -152,7 +152,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);
@@ -31,13 +31,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);
 }
@@ -54,7 +54,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;
@@ -64,7 +64,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;
  }
@@ -73,7 +73,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 {
@@ -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(); }
@@ -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
   */
@@ -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;
  }

  /**
@@ -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();

@@ -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;
  }
 };

@@ -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;
@@ -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;
@@ -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>
@@ -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; }
@@ -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).
@@ -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;
    }
  }

@@ -2,6 +2,9 @@

 #include <cstring>

+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld, size_t maxExcessBytes)
    : RingBufferBase<>(0, size, overwriteOld), maxExcessBytes(maxExcessBytes) {
  if (maxExcessBytes > size) {
@@ -29,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;
  }
 }

@@ -48,6 +51,19 @@ void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
 }

 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data, size_t amount) {
+  if (data == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (amount > getMaxSize()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "SimpleRingBuffer::writeData: Amount of data too large" << std::endl;
+#else
+    sif::printError("SimpleRingBuffer::writeData: Amount of data too large\n");
+#endif
+#endif
+    return returnvalue::FAILED;
+  }
  if (availableWriteSpace() >= amount or overwriteOld) {
    size_t amountTillWrap = writeTillWrap();
    if (amountTillWrap >= amount) {
@@ -58,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;
  }
 }

@@ -73,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) {
@@ -89,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; }
@@ -108,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;
 }
@@ -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,
@@ -13,22 +13,24 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
      submode(SUBMODE_NONE),
      modeHelper(this),
      healthHelper(this, setObjectId) {
-  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }

 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

 ReturnValue_t ControllerBase::initialize() {
  ReturnValue_t result = SystemObject::initialize();
-  if (result != RETURN_OK) {
+  if (result != returnvalue::OK) {
    return result;
  }

  MessageQueueId_t parentQueue = 0;
  if (parentId != objects::NO_OBJECT) {
-    SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
+    auto* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
    if (parent == nullptr) {
-      return RETURN_FAILED;
+      return returnvalue::FAILED;
    }
    parentQueue = parent->getCommandQueue();

@@ -36,36 +38,36 @@ 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(); }

 void ControllerBase::handleQueue() {
  CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-  for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+  ReturnValue_t result;
+  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();
@@ -73,20 +75,20 @@ void ControllerBase::handleQueue() {
  }
 }

-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+void ControllerBase::startTransition(Mode_t mode_, Submode_t submode_) {
  changeHK(this->mode, this->submode, false);
  triggerEvent(CHANGING_MODE, mode, submode);
-  this->mode = mode;
-  this->submode = submode;
+  mode = mode_;
+  submode = submode_;
  modeHelper.modeChanged(mode, submode);
  modeChanged(mode, submode);
  announceMode(false);
  changeHK(this->mode, this->submode, true);
 }

-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-  *mode = this->mode;
-  *submode = this->submode;
+void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) {
+  *mode_ = this->mode;
+  *submode_ = this->submode;
 }

 void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); }
@@ -96,17 +98,17 @@ 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) { return; }
+void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}

 ReturnValue_t ControllerBase::setHealth(HealthState health) {
  switch (health) {
    case HEALTHY:
    case EXTERNAL_CONTROL:
      healthHelper.setHealth(health);
-      return RETURN_OK;
+      return returnvalue::OK;
    default:
      return INVALID_HEALTH_STATE;
  }
@@ -115,6 +117,6 @@ ReturnValue_t ControllerBase::setHealth(HealthState health) {
 HasHealthIF::HealthState ControllerBase::getHealth() { return healthHelper.getHealth(); }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }

-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {}
+void ControllerBase::changeHK(Mode_t mode_, Submode_t submode_, bool enable) {}

-ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return HasReturnvaluesIF::RETURN_OK; }
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() { return returnvalue::OK; }
@@ -18,27 +18,26 @@
 class ControllerBase : public HasModesIF,
                       public HasHealthIF,
                       public ExecutableObjectIF,
-                       public SystemObject,
-                       public HasReturnvaluesIF {
+                       public SystemObject {
 public:
  static const Mode_t MODE_NORMAL = 2;

  ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
-  virtual ~ControllerBase();
+  ~ControllerBase() override;

  /** SystemObject override */
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;

-  virtual MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;

  /** HasHealthIF overrides */
-  virtual ReturnValue_t setHealth(HealthState health) override;
-  virtual HasHealthIF::HealthState getHealth() override;
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;

  /** ExecutableObjectIF overrides */
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual void setTaskIF(PeriodicTaskIF *task) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  void setTaskIF(PeriodicTaskIF *task) override;
+  ReturnValue_t initializeAfterTaskCreation() override;

 protected:
  /**
@@ -54,8 +53,8 @@ class ControllerBase : public HasModesIF,
   */
  virtual void performControlOperation() = 0;

-  virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                                         uint32_t *msToReachTheMode) override = 0;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t *msToReachTheMode) override = 0;

  const object_id_t parentId;

@@ -80,10 +79,10 @@ class ControllerBase : public HasModesIF,

  /** Mode helpers */
  virtual void modeChanged(Mode_t mode, Submode_t submode);
-  virtual void startTransition(Mode_t mode, Submode_t submode) override;
-  virtual void getMode(Mode_t *mode, Submode_t *submode) override;
-  virtual void setToExternalControl() override;
-  virtual void announceMode(bool recursive);
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  void setToExternalControl() override;
+  void announceMode(bool recursive) override;
  /** HK helpers */
  virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
@@ -6,13 +6,13 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t
      poolManager(this, commandQueue),
      actionHelper(this, commandQueue) {}

-ExtendedControllerBase::~ExtendedControllerBase() {}
+ExtendedControllerBase::~ExtendedControllerBase() = default;

 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
                                                    MessageQueueId_t commandedBy,
                                                    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);
@@ -31,31 +31,31 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *messa

 void ExtendedControllerBase::handleQueue() {
  CommandMessage command;
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-  for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+  ReturnValue_t result;
+  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(); }
--- a/Show More
+++ b/Show More