more clang-tidy improvements

Reviewed-on: fsfw/fsfw#643

.gitignore

@@ -1,6 +1,14 @@
+# PyCharm and CLion
+/.idea/*
+!/.idea/runConfigurations
+!/.idea/cmake.xml
+!/.idea/codeStyles
+
+# Eclipse
 .cproject
 .project
 .settings
 .metadata
 
 /build*
+/cmake-build*

.idea/codeStyles/Project.xml

@@ -0,0 +1,14 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <clangFormatSettings>
+      <option name="ENABLED" value="true" />
+    </clangFormatSettings>
+    <codeStyleSettings language="CMake">
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="0" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

.run/fsfw-tests_coverage.run.xml

@@ -0,0 +1,7 @@
+<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-example-hosted" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-example-hosted" RUN_TARGET_NAME="fsfw-tests">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>

.run/fsfw.run.xml

@@ -0,0 +1,7 @@
+<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>

CHANGELOG.md

@@ -12,6 +12,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
+- Renamed auto-formatting script to `auto-formatter.sh` and made it more robust.
+  If `cmake-format` is installed, it will also auto-format the `CMakeLists.txt` files now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/626
 - 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
@@ -25,18 +29,88 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   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
-- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+- Major update for version handling, using `git describe` to fetch version information with git.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601
+  - Add helper functions provided by [`cmake-modules`](https://github.com/bilke/cmake-modules)
+    manually now. Those should not change too often and only a small subset is needed
+  - Separate folder for easier update and for distinction
+  - LICENSE file included
+  - use `int` for version numbers to allow unset or uninitialized version
+  - Initialize Version object with numbers set to -1
+  - Instead of hardcoding the git hash, it is now retrieved from git
+  - `Version` now allows specifying additional version information like the git SHA1 hash and the
+    versions since the last tag
+  - Additional information is set to the last part of the git describe output for `FSFW_VERSION` now.
+  - Version still need to be hand-updated if the FSFW is not included as a submodule for now.
 - IPC Message Queue Handling: Allow passing an optional `MqArgs` argument into the MessageQueue
   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
-- Clock: 
+
-  - `timeval` to `TimeOfDay_t`
+### Task Module Refactoring
-  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+
-  - Moved the statics used by Clock in ClockCommon.cpp to this file
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
-  - Better check for leap seconds
+
-  - Added Unittests for Clock (only getter)
+**Refactoring general task code**
+
+- There was a lot of duplicate/boilerplate code inside the individual task IF OSAL implementations.
+  Remove it by introducing base classes `PeriodicTaskBase` and `FixedTimeslotTaskBase`.
+
+**Refactor PeriodicTaskIF**
+
+- Convert `virtual ReturnValue_t addComponent(object_id_t object)` to
+  `virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0)`, allowing to pass
+  the operation code passed to `performOperation`. Updated API taking
+  an `ExecutableObjectIF` accordingly
+
+**Refactor FixedTimeslotTaskIF**
+
+- Add additional `addSlot` function which takes an `ExecutableObjectIF` pointer and its Object ID
+
+**Refactor FixedSequenceSlot**
+
+- Introduce typedef `CustomCheckFunc` for `ReturnValue_t (*customCheckFunction)(const SlotList&)`.
+- Convert `ReturnValue_t (*customCheckFunction)(const SlotList&)` to
+  `ReturnValue_t (*customCheckFunction)(const SlotList&, void*)`, allowing arbitrary user arguments
+  for the custom checker
+
+**Linux Task Module**
+
+- Use composition instead of inheritance for the `PeriodicPosixTask` and make the `PosixTask` a
+  member of the class
+
+### HAL
+
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+- 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
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+
+### Time
+
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
+https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
+
+- `timeval` to `TimeOfDay_t`
+- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+- Moved the statics used by Clock in ClockCommon.cpp to this file
+- Better check for leap seconds
+- Added Unittests for Clock (only getter)
+
+### Power 
+
+- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
+  also specify a `ReturnValue_t` return type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
+  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 
 ## Removed
 
@@ -46,12 +120,38 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Additions
 
+- 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
+- Basic `clion` support: Update `.gitignore` and add some basic run configurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
+- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
+  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
+  can make good use of it and it usually makes the code faster and/or smaller.
+  After some more research:
+  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
+  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
+  because if an application linking against the FSFW does not use LTO, there can be compile
+  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
+  can be seen in the multiple CMake issues for it: 
+    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
+    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
+    - 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
+- Added generic PUS TC Scheduler Service 11. It depends on the new added Emebeded Template Library
+  (ETL) dependency.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/594
 - Added ETL dependency and improved library dependency management
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
+- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- New typedef for switcher type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
 ## Fixed

CMakeLists.txt

@@ -1,50 +1,114 @@
 cmake_minimum_required(VERSION 3.13)
 
-set(LIB_FSFW_NAME fsfw)
+set(MSG_PREFIX "fsfw |")
-project(${LIB_FSFW_NAME})
-
-if(NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_STANDARD_REQUIRED True)
-elseif(${CMAKE_CXX_STANDARD} LESS 17)
-    message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++17 support")
-endif()
-
-set(FSFW_VERSION 4)
-set(FSFW_SUBVERSION 0)
-set(FSFW_REVISION 0)
 
 # Add the cmake folder so the FindSphinx module is found
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH
+     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/bilke")
+list(APPEND CMAKE_MODULE_PATH
+     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules/rpavlik")
 
-set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
+# ##############################################################################
-    "ETL library major version requirement"
+# Version file handling  #
-)
+# ##############################################################################
-set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
-    "ETL library exact version requirement"
-)
-set(FSFW_ETL_LINK_TARGET etl::etl)
 
-set(FSFW_CATCH2_LIB_MAJOR_VERSION 3 CACHE STRING
+set(FSFW_VERSION_IF_GIT_FAILS 4)
-    "Catch2 library major version requirement"
+set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
-)
+set(FSFW_REVISION_IF_GIT_FAILS 0)
-set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE STRING
-    "Catch2 library exact version requirement"
-)
 
-set(FSFW_ETL_LIB_NAME etl)
+set(FSFW_GIT_VER_HANDLING_OK FALSE)
-
+# Version handling
-option(FSFW_GENERATE_SECTIONS
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-    "Generate function and data sections. Required to remove unused code" ON
+  message(STATUS "${MSG_PREFIX} Determining version information with git")
-)
+  include(FsfwHelpers)
-if(FSFW_GENERATE_SECTIONS)
+  determine_version_with_git("--exclude" "docker_*")
-    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+  if(GIT_INFO)
+    set(FSFW_GIT_INFO
+        ${GIT_INFO}
+        CACHE STRING "Version information retrieved with git describe")
+    list(GET FSFW_GIT_INFO 1 FSFW_VERSION)
+    list(GET FSFW_GIT_INFO 2 FSFW_SUBVERSION)
+    list(GET FSFW_GIT_INFO 3 FSFW_REVISION)
+    list(GET FSFW_GIT_INFO 4 FSFW_VCS_INFO)
+    if(NOT FSFW_VERSION)
+      set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+    endif()
+    if(NOT FSFW_SUBVERSION)
+      set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+    endif()
+    if(NOT FSFW_REVISION)
+      set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
+    endif()
+    set(FSFW_GIT_VER_HANDLING_OK TRUE)
+  else()
+    set(FSFW_GIT_VER_HANDLING_OK FALSE)
+  endif()
+endif()
+if(NOT FSFW_GIT_VER_HANDLING_OK)
+  set(FSFW_VERSION ${FSFW_VERSION_IF_GIT_FAILS})
+  set(FSFW_SUBVERSION ${FSFW_SUBVERSION_IF_GIT_FAILS})
+  set(FSFW_REVISION ${FSFW_REVISION_IF_GIT_FAILS})
 endif()
 
-option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
+set(LIB_FSFW_NAME fsfw)
+project(${LIB_FSFW_NAME}
+        VERSION ${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION})
+
+if(NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED True)
+elseif(${CMAKE_CXX_STANDARD} LESS 17)
+  message(
+    FATAL_ERROR
+      "${MSG_PREFIX} Compiling the FSFW requires a minimum of C++17 support")
+endif()
+
+set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")
+
+set(FSFW_ETL_LIB_NAME etl)
+set(FSFW_ETL_LIB_MAJOR_VERSION
+    20
+    CACHE STRING "ETL library major version requirement")
+set(FSFW_ETL_LIB_VERSION
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
+    CACHE STRING "ETL library exact version requirement")
+set(FSFW_ETL_LINK_TARGET etl::etl)
+
+set(FSFW_CATCH2_LIB_MAJOR_VERSION
+    3
+    CACHE STRING "Catch2 library major version requirement")
+set(FSFW_CATCH2_LIB_VERSION
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
+    CACHE STRING "Catch2 library exact version requirement")
+
+# Keep this off by default for now. See PR:
+# https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
+# keeping this on by default is problematic
+option(
+  FSFW_ENABLE_IPO
+  "Enable interprocedural optimization or link-time optimization if available"
+  OFF)
+if(FSFW_ENABLE_IPO)
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_ERROR)
+  if(NOT IPO_SUPPORTED)
+    message(STATUS "FSFW | IPO/LTO not supported: ${IPO_ERROR}")
+  endif()
+endif()
+
+option(FSFW_GENERATE_SECTIONS
+       "Generate function and data sections. Required to remove unused code" ON)
+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_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)
-    option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
+  option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()
 
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
@@ -65,88 +129,93 @@ option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
 # Contrib sources
 option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
 
-
 set(FSFW_TEST_TGT fsfw-tests)
 set(FSFW_DUMMY_TGT fsfw-dummy)
 
 add_library(${LIB_FSFW_NAME})
 
-if(FSFW_BUILD_UNITTESTS)
+if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
-    message(STATUS "Building the FSFW unittests in addition to the static library")
+  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
-    # Check whether the user has already installed Catch2 first
+                                                TRUE)
-    find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
-    # Not installed, so use FetchContent to download and provide Catch2
-    if(NOT Catch2_FOUND)
-        message(STATUS "Catch2 installation not found. Downloading Catch2 library with FetchContent")
-        include(FetchContent)
-
-        FetchContent_Declare(
-            Catch2
-            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-            GIT_TAG        ${FSFW_CATCH2_LIB_VERSION}
-        )
-
-        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)
-
-    project(${FSFW_TEST_TGT} CXX C)
-    add_executable(${FSFW_TEST_TGT})
-
-    if(FSFW_TESTS_GEN_COV)
-        message(STATUS "Generating coverage data for the library")
-        message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
-            "will be compiled with coverage data as well"
-        )
-        include(FetchContent)
-        FetchContent_Declare(
-            cmake-modules
-            GIT_REPOSITORY https://github.com/bilke/cmake-modules.git
-        )
-        FetchContent_MakeAvailable(cmake-modules)
-        set(CMAKE_BUILD_TYPE "Debug")
-        list(APPEND CMAKE_MODULE_PATH ${cmake-modules_SOURCE_DIR})
-        include(CodeCoverage)
-    endif()
 endif()
 
-message(STATUS "Finding and/or providing ETL library")
+if(FSFW_BUILD_UNITTESTS)
+  message(
+    STATUS
+      "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
+  )
+  # Check whether the user has already installed Catch2 first
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+  # Not installed, so use FetchContent to download and provide Catch2
+  if(NOT Catch2_FOUND)
+    message(
+      STATUS
+        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
+    )
+    include(FetchContent)
+
+    FetchContent_Declare(
+      Catch2
+      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+      GIT_TAG ${FSFW_CATCH2_LIB_VERSION})
+
+    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)
+
+  project(${FSFW_TEST_TGT} CXX C)
+  add_executable(${FSFW_TEST_TGT})
+  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
+                                                  TRUE)
+  endif()
+
+  if(FSFW_TESTS_GEN_COV)
+    message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
+    message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
+                   "will be compiled with coverage data as well")
+    set(CMAKE_BUILD_TYPE "Debug")
+    include(CodeCoverage)
+  endif()
+endif()
+
+message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
 
 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
-    message(STATUS
+  message(
-        "No ETL installation was found with find_package. Installing and providing "
+    STATUS
-        "etl with FindPackage"
+      "No ETL installation was found with find_package. Installing and providing "
-    )
+      "etl with FindPackage")
-    include(FetchContent)
+  include(FetchContent)
 
-    FetchContent_Declare(
+  FetchContent_Declare(
-        ${FSFW_ETL_LIB_NAME}
+    ${FSFW_ETL_LIB_NAME}
-        GIT_REPOSITORY https://github.com/ETLCPP/etl
+    GIT_REPOSITORY https://github.com/ETLCPP/etl
-        GIT_TAG        ${FSFW_ETL_LIB_VERSION}
+    GIT_TAG ${FSFW_ETL_LIB_VERSION})
-    )
 
-    list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
+  list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
 endif()
 
 # The documentation for FetchContent recommends declaring all the dependencies
 # before making them available. We make all declared dependency available here
 # after their declaration
 if(FSFW_FETCH_CONTENT_TARGETS)
-    FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
+  FetchContent_MakeAvailable(${FSFW_FETCH_CONTENT_TARGETS})
-    if(TARGET ${FSFW_ETL_LIB_NAME})
+  if(TARGET ${FSFW_ETL_LIB_NAME})
-        add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
+    add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
-    endif()
+  endif()
-    if(TARGET Catch2)
+  if(TARGET Catch2)
-        # Fixes regression -preview4, to be confirmed in later releases
+    # Fixes regression -preview4, to be confirmed in later releases Related
-        # Related GitHub issue: https://github.com/catchorg/Catch2/issues/2417
+    # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
-        set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
-    endif()
+  endif()
 endif()
 
 set(FSFW_CORE_INC_PATH "inc")
@@ -154,269 +223,242 @@ set(FSFW_CORE_INC_PATH "inc")
 set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)
 
 # For configure files
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
+target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-    ${CMAKE_CURRENT_BINARY_DIR}
+target_include_directories(${LIB_FSFW_NAME}
-)
+                           INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
-target_include_directories(${LIB_FSFW_NAME} INTERFACE
-    ${CMAKE_CURRENT_BINARY_DIR}
-)
-
 
 # Backwards comptability
 if(OS_FSFW AND NOT FSFW_OSAL)
-    message(WARNING "Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+  message(
-    set(FSFW_OSAL OS_FSFW)
+    WARNING
+      "${MSG_PREFIX} Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+  set(FSFW_OSAL OS_FSFW)
 endif()
 
 if(NOT FSFW_OSAL)
-	message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
+  message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
-	# Assume host OS and autodetermine from OS_FSFW
+  # Assume host OS and autodetermine from OS_FSFW
-	if(UNIX)
+  if(UNIX)
-		set(FSFW_OSAL  "linux" 
+    set(FSFW_OSAL
-			CACHE STRING 
+        "linux"
-			"OS abstraction layer used in the FSFW"
+        CACHE STRING "OS abstraction layer used in the FSFW")
-		)
+  elseif(WIN32)
-	elseif(WIN32)
+    set(FSFW_OSAL
-		set(FSFW_OSAL  "host" 
+        "host"
-			CACHE STRING "OS abstraction layer used in the FSFW"
+        CACHE STRING "OS abstraction layer used in the FSFW")
-		)
+  endif()
-	endif()
-
 endif()
 
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 
 if(FSFW_OSAL MATCHES host)
-    set(FSFW_OS_NAME "Host")
+  set(FSFW_OS_NAME "Host")
-    set(FSFW_OSAL_HOST ON)
+  set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-    set(FSFW_OS_NAME "Linux")
+  set(FSFW_OS_NAME "Linux")
-    set(FSFW_OSAL_LINUX ON)
+  set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-    set(FSFW_OS_NAME "FreeRTOS")
+  set(FSFW_OS_NAME "FreeRTOS")
-    set(FSFW_OSAL_FREERTOS ON)
+  set(FSFW_OSAL_FREERTOS ON)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
-        ${LIB_OS_NAME}
-    )
 elseif(FSFW_OSAL STREQUAL rtems)
-    set(FSFW_OS_NAME "RTEMS")
+  set(FSFW_OS_NAME "RTEMS")
-    set(FSFW_OSAL_RTEMS ON)
+  set(FSFW_OSAL_RTEMS ON)
 else()
-    message(WARNING
+  message(
-        "Invalid operating system for FSFW specified! Setting to host.."
+    WARNING
-    )
+      "${MSG_PREFIX} Invalid operating system for FSFW specified! Setting to host.."
-    set(FSFW_OS_NAME "Host")
+  )
-    set(OS_FSFW "host")
+  set(FSFW_OS_NAME "Host")
+  set(OS_FSFW "host")
 endif()
 
 configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
 configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)
 
-message(STATUS "Compiling FSFW for the ${FSFW_OS_NAME} operating system.")
+message(
+  STATUS "${MSG_PREFIX} Compiling FSFW for the ${FSFW_OS_NAME} operating system"
+)
 
 add_subdirectory(src)
 add_subdirectory(tests)
 if(FSFW_ADD_HAL)
-    add_subdirectory(hal)
+  add_subdirectory(hal)
 endif()
 add_subdirectory(contrib)
 if(FSFW_BUILD_DOCS)
-    add_subdirectory(docs)
+  add_subdirectory(docs)
 endif()
 
 if(FSFW_BUILD_UNITTESTS)
-    if(FSFW_TESTS_GEN_COV)
+  if(FSFW_TESTS_GEN_COV)
-        if(CMAKE_COMPILER_IS_GNUCXX)
+    if(CMAKE_COMPILER_IS_GNUCXX)
-            include(CodeCoverage)
+      include(CodeCoverage)
 
-            # Remove quotes.
+      # Remove quotes.
-            separate_arguments(COVERAGE_COMPILER_FLAGS
+      separate_arguments(COVERAGE_COMPILER_FLAGS NATIVE_COMMAND
-                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+                         "${COVERAGE_COMPILER_FLAGS}")
-            )
 
-            # Add compile options manually, we don't want coverage for Catch2
+      # Add compile options manually, we don't want coverage for Catch2
-            target_compile_options(${FSFW_TEST_TGT} PRIVATE
+      target_compile_options(${FSFW_TEST_TGT}
-                "${COVERAGE_COMPILER_FLAGS}"
+                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
-            )
+      target_compile_options(${LIB_FSFW_NAME}
-            target_compile_options(${LIB_FSFW_NAME} PRIVATE
+                             PRIVATE "${COVERAGE_COMPILER_FLAGS}")
-                "${COVERAGE_COMPILER_FLAGS}"
-            )
 
-            # Exclude directories here
+      # Exclude directories here
-            if(WIN32)
+      if(WIN32)
-                set(GCOVR_ADDITIONAL_ARGS
+        set(GCOVR_ADDITIONAL_ARGS "--exclude-throw-branches"
-                    "--exclude-throw-branches"
+                                  "--exclude-unreachable-branches")
-                    "--exclude-unreachable-branches"
+        set(COVERAGE_EXCLUDES "/c/msys64/mingw64/*" "*/fsfw_hal/*")
-                )
+      elseif(UNIX)
-                set(COVERAGE_EXCLUDES
+        set(COVERAGE_EXCLUDES
-                    "/c/msys64/mingw64/*" "*/fsfw_hal/*"
+            "/usr/include/*"
-                )
+            "/usr/bin/*"
-            elseif(UNIX)
+            "Catch2/*"
-                set(COVERAGE_EXCLUDES
+            "/usr/local/include/*"
-                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
+            "*/fsfw_tests/*"
-                    "/usr/local/include/*" "*/fsfw_tests/*"
+            "*/catch2-src/*"
-                    "*/catch2-src/*" "*/fsfw_hal/*"
+            "*/fsfw_hal/*")
-                )
+      endif()
-            endif()
 
-            target_link_options(${FSFW_TEST_TGT} PRIVATE
+      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
-                -fprofile-arcs
+                          -ftest-coverage)
-                -ftest-coverage
+      target_link_options(${LIB_FSFW_NAME} PRIVATE -fprofile-arcs
-            )
+                          -ftest-coverage)
-            target_link_options(${LIB_FSFW_NAME} PRIVATE
+      # Need to specify this as an interface, otherwise there will the compile
-                -fprofile-arcs
+      # issues
-                -ftest-coverage
+      target_link_options(${LIB_FSFW_NAME} INTERFACE -fprofile-arcs
-            )
+                          -ftest-coverage)
-            # Need to specify this as an interface, otherwise there will the compile issues
-            target_link_options(${LIB_FSFW_NAME} INTERFACE
-                -fprofile-arcs
-                -ftest-coverage
-            )
 
-            if(WIN32)
+      if(WIN32)
-                setup_target_for_coverage_gcovr_html(
+        setup_target_for_coverage_gcovr_html(
-                    NAME ${FSFW_TEST_TGT}_coverage
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-                    EXECUTABLE ${FSFW_TEST_TGT}
+          DEPENDENCIES ${FSFW_TEST_TGT})
-                    DEPENDENCIES ${FSFW_TEST_TGT}
+      else()
-                )
+        setup_target_for_coverage_lcov(
-            else()
+          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-                setup_target_for_coverage_lcov(
+          DEPENDENCIES ${FSFW_TEST_TGT})
-                    NAME ${FSFW_TEST_TGT}_coverage
+      endif()
-                    EXECUTABLE ${FSFW_TEST_TGT}
-                    DEPENDENCIES ${FSFW_TEST_TGT}
-                )
-            endif()
-        endif()
     endif()
-    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
+  endif()
+  target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
+                                                 ${LIB_FSFW_NAME})
 endif()
 
-# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If
-# If this is not given, we include the default configuration and emit a warning.
+# this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
+  set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
-    if(NOT FSFW_BUILD_DOCS)
+  if(NOT FSFW_BUILD_DOCS)
-        message(WARNING "Flight Software Framework configuration path not set!")
+    message(
-        message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
+      WARNING
-    endif()
+        "${MSG_PREFIX} Flight Software Framework configuration path not set")
-    add_subdirectory(${DEF_CONF_PATH})
+    message(
-    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
+      WARNING
+        "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
+  endif()
+  add_subdirectory(${DEF_CONF_PATH})
+  set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()
 
-# FSFW might be part of a possibly complicated folder structure, so we 
+# FSFW might be part of a possibly complicated folder structure, so we extract
-# extract the absolute path of the fsfwconfig folder.
+# the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
-	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
+  set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
+  get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH} REALPATH
-		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+                         BASE_DIR ${CMAKE_SOURCE_DIR})
-	)
 endif()
 
 foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATHS})
-    if(IS_ABSOLUTE ${INCLUDE_PATH})
+  if(IS_ABSOLUTE ${INCLUDE_PATH})
-        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+    set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
-    else()
+  else()
-        get_filename_component(CURR_ABS_INC_PATH
+    get_filename_component(CURR_ABS_INC_PATH ${INCLUDE_PATH} REALPATH BASE_DIR
-            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+                           ${CMAKE_SOURCE_DIR})
-    endif()
+  endif()
 
-    if(CMAKE_VERBOSE)
+  if(CMAKE_VERBOSE)
-        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
-    endif()
+  endif()
 
-    list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+  list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
 endforeach()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if(NOT DEFINED FSFW_WARNING_FLAGS)
+  if(NOT DEFINED FSFW_WARNING_FLAGS)
-	   set(FSFW_WARNING_FLAGS
+    set(FSFW_WARNING_FLAGS
-		  -Wall
+        -Wall
-		  -Wextra
+        -Wextra
-		  -Wimplicit-fallthrough=1
+        -Wimplicit-fallthrough=1
-		  -Wno-unused-parameter
+        -Wno-unused-parameter
-		  -Wno-psabi
+        -Wno-psabi
-          -Wduplicated-cond # check for duplicate conditions
+        -Wduplicated-cond # check for duplicate conditions
-          -Wduplicated-branches # check for duplicate branches
+        -Wduplicated-branches # check for duplicate branches
-          -Wlogical-op # Search for bitwise operations instead of logical 
+        -Wlogical-op # Search for bitwise operations instead of logical
-          -Wnull-dereference # Search for NULL dereference
+        -Wnull-dereference # Search for NULL dereference
-          -Wundef # Warn if undefind marcos are used
+        -Wundef # Warn if undefind marcos are used
-          -Wformat=2 # Format string problem detection
+        -Wformat=2 # Format string problem detection
-          -Wformat-overflow=2 # Formatting issues in printf
+        -Wformat-overflow=2 # Formatting issues in printf
-          -Wformat-truncation=2 # Formatting issues in printf
+        -Wformat-truncation=2 # Formatting issues in printf
-          -Wformat-security # Search for dangerous printf operations
+        -Wformat-security # Search for dangerous printf operations
-          -Wstrict-overflow=3 # Warn if integer overflows might happen
+        -Wstrict-overflow=3 # Warn if integer overflows might happen
-          -Warray-bounds=2 # Some array bounds violations will be found
+        -Warray-bounds=2 # Some array bounds violations will be found
-          -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
+        -Wshift-overflow=2 # Search for bit left shift overflows (<c++14)
-          -Wcast-qual # Warn if the constness is cast away
+        -Wcast-qual # Warn if the constness is cast away
-          -Wstringop-overflow=4
+        -Wstringop-overflow=4
-          # -Wstack-protector # Emits a few false positives for low level access
+        # -Wstack-protector # Emits a few false positives for low level access
-          # -Wconversion # Creates many false positives
+        # -Wconversion # Creates many false positives -Warith-conversion # Use
-          # -Warith-conversion # Use with Wconversion to find more implicit conversions
+        # with Wconversion to find more implicit conversions -fanalyzer # Should
-          # -fanalyzer # Should be used to look through problems
+        # be used to look through problems
-        )
+    )
-    endif()
+  endif()
 
-    if(FSFW_GENERATE_SECTIONS)
+  if(FSFW_GENERATE_SECTIONS)
-        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+    target_compile_options(${LIB_FSFW_NAME} PRIVATE "-ffunction-sections"
-            "-ffunction-sections"
+                                                    "-fdata-sections")
-            "-fdata-sections"
+  endif()
-        )
+
-    endif()
+  if(FSFW_REMOVE_UNUSED_CODE)
+    target_link_options(${LIB_FSFW_NAME} PRIVATE "Wl,--gc-sections")
+  endif()
+
+  if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+    list(APPEND WARNING_FLAGS "-Wshadow=local")
+  endif()
 
-    if(FSFW_REMOVE_UNUSED_CODE)
-        target_link_options(${LIB_FSFW_NAME} PRIVATE
-            "Wl,--gc-sections"
-        )
-    endif()
-  
-    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
-        list(APPEND WARNING_FLAGS "-Wshadow=local")
-    endif()
-	
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-	set(COMPILER_FLAGS "/permissive-")
+  set(COMPILER_FLAGS "/permissive-")
 endif()
 
 # Required include paths to compile the FSFW
-target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+target_include_directories(
-	${CMAKE_SOURCE_DIR}
+  ${LIB_FSFW_NAME} INTERFACE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-	${FSFW_CONFIG_PATH_ABSOLUTE}
+                             ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
-	${FSFW_CORE_INC_PATH}
-	${FSFW_ADD_INC_PATHS_ABS}
-)
 
-# Includes path required to compile FSFW itself as well
+# Includes path required to compile FSFW itself as well We assume that the
-# We assume that the fsfwconfig folder uses include relative to the project
+# fsfwconfig folder uses include relative to the project root here!
-# root here!
+target_include_directories(
-target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE ${CMAKE_SOURCE_DIR} ${FSFW_CONFIG_PATH_ABSOLUTE}
-	${CMAKE_SOURCE_DIR}
+                           ${FSFW_CORE_INC_PATH} ${FSFW_ADD_INC_PATHS_ABS})
-	${FSFW_CONFIG_PATH_ABSOLUTE}
-	${FSFW_CORE_INC_PATH}
-	${FSFW_ADD_INC_PATHS_ABS}
-)
 
-target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
-	${FSFW_WARNING_FLAGS}
+                                                ${COMPILER_FLAGS})
-	${COMPILER_FLAGS}
-)
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-    ${FSFW_ETL_LINK_TARGET}
+                                               ${FSFW_ADDITIONAL_LINK_LIBS})
-    ${FSFW_ADDITIONAL_LINK_LIBS}
-)
 
-string(CONCAT POST_BUILD_COMMENT
+string(
+  CONCAT
+    POST_BUILD_COMMENT
     "######################################################################\n"
     "Built FSFW v${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION}, "
     "Target OSAL: ${FSFW_OS_NAME}\n"
-    "######################################################################\n"
+    "######################################################################\n")
-)
 
 add_custom_command(
-   TARGET ${LIB_FSFW_NAME}
+  TARGET ${LIB_FSFW_NAME}
-   POST_BUILD
+  POST_BUILD
-   COMMENT ${POST_BUILD_COMMENT}
+  COMMENT ${POST_BUILD_COMMENT})
-)

README.md

@@ -99,7 +99,7 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-   ```cmake
+   ```sh
    target_link_libraries(${YourProjectName} PRIVATE fsfw)
    ```
 
@@ -131,7 +131,7 @@ default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF
 You can use the following commands inside the `fsfw` folder to set up the build system
 
 ```sh
-mkdir build-Unittest && cd build-Unittest
+mkdir build-tests && cd build-tests
 cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 

automation/Jenkinsfile

@@ -14,7 +14,7 @@ pipeline {
         stage('Configure') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
                 }
             }
         }

cmake/FsfwHelpers.cmake

@@ -0,0 +1,28 @@
+# Determines the git version with git describe and returns it by setting
+# the GIT_INFO list in the parent scope. The list has the following entries
+# 1. Full version string
+# 2. Major version
+# 3. Minor version
+# 4. Revision
+# 5. git SHA hash and commits since tag
+function(determine_version_with_git)
+    include(GetGitRevisionDescription)
+    git_describe(VERSION ${ARGN})
+    string(FIND ${VERSION} "." VALID_VERSION)
+    if(VALID_VERSION EQUAL -1)
+        message(WARNING "Version string ${VERSION} retrieved with git describe is invalid")
+        return()
+    endif()
+    # Parse the version information into pieces.
+    string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" _VERSION_MAJOR "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" _VERSION_MINOR "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" _VERSION_PATCH "${VERSION}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+-(.*)" "\\1" VERSION_SHA1 "${VERSION}")
+    set(GIT_INFO ${VERSION})
+    list(APPEND GIT_INFO ${_VERSION_MAJOR})
+    list(APPEND GIT_INFO ${_VERSION_MINOR})
+    list(APPEND GIT_INFO ${_VERSION_PATCH})
+    list(APPEND GIT_INFO ${VERSION_SHA1})
+    set(GIT_INFO ${GIT_INFO} PARENT_SCOPE)
+    message(STATUS "${MSG_PREFIX} Set git version info into GIT_INFO from the git tag ${VERSION}")
+endfunction()

cmake/cmake-modules/README.md

@@ -0,0 +1,7 @@
+The files in the `bilke` folder were manually copy and pasted from the
+[cmake-modules repository](https://github.com/bilke/cmake-modules). It was decided to do
+this because only a small subset of its provided functions are needed.
+
+The files in the `rpavlik` folder were manually copy and pasted from the
+[cmake-modules repository](https://github.com/rpavlik/cmake-modules). It was decided to do
+this because only a small subset of its provided functions are needed.

cmake/cmake-modules/bilke/CodeCoverage.cmake

@@ -0,0 +1,719 @@
+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+# 2019-05-06, Anatolii Kurotych
+# - Remove unnecessary --coverage flag
+#
+# 2019-12-13, FeRD (Frank Dana)
+# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
+#   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
+# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
+# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
+# - Set lcov basedir with -b argument
+# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
+#   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
+# - Delete output dir, .info file on 'make clean'
+# - Remove Python detection, since version mismatches will break gcovr
+# - Minor cleanup (lowercase function names, update examples...)
+#
+# 2019-12-19, FeRD (Frank Dana)
+# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
+#
+# 2020-01-19, Bob Apthorpe
+# - Added gfortran support
+#
+# 2020-02-17, FeRD (Frank Dana)
+# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
+#   in EXCLUDEs, and remove manual escaping from gcovr targets
+#
+# 2021-01-19, Robin Mueller
+# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
+# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
+#   flags to the gcovr command
+#
+# 2020-05-04, Mihchael Davis
+#     - Add -fprofile-abs-path to make gcno files contain absolute paths
+#     - Fix BASE_DIRECTORY not working when defined
+#     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
+#
+# 2021-05-10, Martin Stump
+#     - Check if the generator is multi-config before warning about non-Debug builds
+#
+# 2022-02-22, Marko Wehle
+#     - Change gcovr output from -o <filename> for --xml <filename> and --html <filename> output respectively.
+#       This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt".
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt (best inside an if-condition
+#    using a CMake option() to enable it just optionally):
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags for all supported source files:
+#      append_coverage_compiler_flags()
+#    Or for specific target:
+#      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
+#
+# 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using full paths in the COVERAGE_EXCLUDES variable before calling
+#    setup_target_for_coverage_*().
+#    Example:
+#      set(COVERAGE_EXCLUDES
+#          '${PROJECT_SOURCE_DIR}/src/dir1/*'
+#          '/path/to/my/src/dir2/*')
+#    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
+#    Example:
+#      setup_target_for_coverage_lcov(
+#          NAME coverage
+#          EXECUTABLE testrunner
+#          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
+#
+# 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
+#     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
+#     Example:
+#       set(COVERAGE_EXCLUDES "dir1/*")
+#       setup_target_for_coverage_gcovr_html(
+#           NAME coverage
+#           EXECUTABLE testrunner
+#           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
+#           EXCLUDE "dir2/*")
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+#
+
+include(CMakeParseArguments)
+
+option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
+
+# Check prereqs
+find_program( GCOV_PATH gcov )
+find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
+find_program( FASTCOV_PATH NAMES fastcov fastcov.py )
+find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
+find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( CPPFILT_PATH NAMES c++filt )
+
+if(NOT GCOV_PATH)
+    message(FATAL_ERROR "gcov not found! Aborting...")
+endif() # NOT GCOV_PATH
+
+get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
+list(GET LANGUAGES 0 LANG)
+
+if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+        message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+    endif()
+elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
+    if("${CMAKE_Fortran_COMPILER_ID}" MATCHES "[Ff]lang")
+        # Do nothing; exit conditional without error if true
+    elseif("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
+        # Do nothing; exit conditional without error if true
+    else()
+        message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+    endif()
+endif()
+
+set(COVERAGE_COMPILER_FLAGS "-g -fprofile-arcs -ftest-coverage"
+    CACHE INTERNAL "")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path)
+    if(HAVE_fprofile_abs_path)
+        set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+endif()
+
+set(CMAKE_Fortran_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
+    FORCE )
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_Fortran_FLAGS_COVERAGE
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
+endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_lcov(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+#     BASE_DIRECTORY "../"                        # Base directory for report
+#                                                 #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"           # Patterns to exclude (can be relative
+#                                                 #  to BASE_DIRECTORY, with CMake 3.4+)
+#     NO_DEMANGLE                                 # Don't demangle C++ symbols
+#                                                 #  even if c++filt is found
+# )
+function(setup_target_for_coverage_lcov)
+
+    set(options NO_DEMANGLE)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS GENHTML_ARGS)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT LCOV_PATH)
+        message(FATAL_ERROR "lcov not found! Aborting...")
+    endif() # NOT LCOV_PATH
+
+    if(NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif() # NOT GENHTML_PATH
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(LCOV_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_LCOV_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND LCOV_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES LCOV_EXCLUDES)
+
+    # Conditional arguments
+    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
+      set(GENHTML_EXTRA_ARGS "--demangle-cpp")
+    endif()
+     
+    # Setting up commands which will be run to generate coverage data.
+    # Cleanup lcov
+    set(LCOV_CLEAN_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -directory . 
+        -b ${BASEDIR} --zerocounters
+    )
+    # Create baseline to make sure untouched files show up in the report
+    set(LCOV_BASELINE_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -c -i -d . -b 
+        ${BASEDIR} -o ${Coverage_NAME}.base
+    )
+    # Run tests
+    set(LCOV_EXEC_TESTS_CMD 
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )    
+    # Capturing lcov counters and generating report
+    set(LCOV_CAPTURE_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --directory . -b 
+        ${BASEDIR} --capture --output-file ${Coverage_NAME}.capture
+    )
+    # add baseline counters
+    set(LCOV_BASELINE_COUNT_CMD
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base 
+        -a ${Coverage_NAME}.capture --output-file ${Coverage_NAME}.total
+    ) 
+    # filter collected data to final coverage report
+    set(LCOV_FILTER_CMD 
+        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --remove 
+        ${Coverage_NAME}.total ${LCOV_EXCLUDES} --output-file ${Coverage_NAME}.info
+    )    
+    # Generate HTML output
+    set(LCOV_GEN_HTML_CMD
+        ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o 
+        ${Coverage_NAME} ${Coverage_NAME}.info
+    )
+    
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+        message(STATUS "Command to clean up lcov: ")
+        string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}")
+        message(STATUS "${LCOV_CLEAN_CMD_SPACED}")
+
+        message(STATUS "Command to create baseline: ")
+        string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}")
+        message(STATUS "${LCOV_BASELINE_CMD_SPACED}")
+
+        message(STATUS "Command to run the tests: ")
+        string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}")
+        message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}")
+
+        message(STATUS "Command to capture counters and generate report: ")
+        string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}")
+        message(STATUS "${LCOV_CAPTURE_CMD_SPACED}")
+
+        message(STATUS "Command to add baseline counters: ")
+        string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED "${LCOV_BASELINE_COUNT_CMD}")
+        message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}")
+
+        message(STATUS "Command to filter collected data: ")
+        string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}")
+        message(STATUS "${LCOV_FILTER_CMD_SPACED}")
+
+        message(STATUS "Command to generate lcov HTML output: ")
+        string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}")
+        message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}")
+    endif()
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${LCOV_CLEAN_CMD}
+        COMMAND ${LCOV_BASELINE_CMD} 
+        COMMAND ${LCOV_EXEC_TESTS_CMD}
+        COMMAND ${LCOV_CAPTURE_CMD}
+        COMMAND ${LCOV_BASELINE_COUNT_CMD}
+        COMMAND ${LCOV_FILTER_CMD} 
+        COMMAND ${LCOV_GEN_HTML_CMD}
+
+        # Set output files as GENERATED (will be removed on 'make clean')
+        BYPRODUCTS
+            ${Coverage_NAME}.base
+            ${Coverage_NAME}.capture
+            ${Coverage_NAME}.total
+            ${Coverage_NAME}.info
+            ${Coverage_NAME}/index.html
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+    )
+
+    # Show where to find the lcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # setup_target_for_coverage_lcov
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_gcovr_xml(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+#     BASE_DIRECTORY "../"                   # Base directory for report
+#                                            #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
+#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
+# )
+# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
+# GCVOR command.
+function(setup_target_for_coverage_gcovr_xml)
+
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDE_ARGS "")
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
+        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
+    endforeach()
+    
+    # Set up commands which will be run to generate coverage data
+    # Run tests
+    set(GCOVR_XML_EXEC_TESTS_CMD
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )
+    # Running gcovr
+    set(GCOVR_XML_CMD
+        ${GCOVR_PATH} --xml ${Coverage_NAME}.xml -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
+        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
+    )
+    
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+
+        message(STATUS "Command to run tests: ")
+        string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED "${GCOVR_XML_EXEC_TESTS_CMD}")
+        message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}")
+
+        message(STATUS "Command to generate gcovr XML coverage data: ")
+        string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
+        message(STATUS "${GCOVR_XML_CMD_SPACED}")
+    endif()
+
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${GCOVR_XML_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_XML_CMD}
+        
+        BYPRODUCTS ${Coverage_NAME}.xml
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce Cobertura code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
+    )
+endfunction() # setup_target_for_coverage_gcovr_xml
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_gcovr_html(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+#     BASE_DIRECTORY "../"                   # Base directory for report
+#                                            #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
+#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
+# )
+# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
+# GCVOR command.
+function(setup_target_for_coverage_gcovr_html)
+
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDE_ARGS "")
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
+        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
+    endforeach()
+
+    # Set up commands which will be run to generate coverage data
+    # Run tests
+    set(GCOVR_HTML_EXEC_TESTS_CMD
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )
+    # Create folder
+    set(GCOVR_HTML_FOLDER_CMD
+        ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
+    )
+    # Running gcovr
+    set(GCOVR_HTML_CMD
+        ${GCOVR_PATH} --html ${Coverage_NAME}/index.html --html-details -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
+        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
+    )
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+
+        message(STATUS "Command to run tests: ")
+        string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED "${GCOVR_HTML_EXEC_TESTS_CMD}")
+        message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}")
+
+        message(STATUS "Command to create a folder: ")
+        string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED "${GCOVR_HTML_FOLDER_CMD}")
+        message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}")
+
+        message(STATUS "Command to generate gcovr HTML coverage data: ")
+        string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}")
+        message(STATUS "${GCOVR_HTML_CMD_SPACED}")
+    endif()
+
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${GCOVR_HTML_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_HTML_FOLDER_CMD}
+        COMMAND ${GCOVR_HTML_CMD}
+
+        BYPRODUCTS ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html  # report directory
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce HTML code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # setup_target_for_coverage_gcovr_html
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_fastcov(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+#     BASE_DIRECTORY "../"                        # Base directory for report
+#                                                 #  (defaults to PROJECT_SOURCE_DIR)
+#     EXCLUDE "src/dir1/" "src/dir2/"             # Patterns to exclude.
+#     NO_DEMANGLE                                 # Don't demangle C++ symbols
+#                                                 #  even if c++filt is found
+#     SKIP_HTML                                   # Don't create html report
+#     POST_CMD perl -i -pe s!${PROJECT_SOURCE_DIR}/!!g ctest_coverage.json  # E.g. for stripping source dir from file paths
+# )
+function(setup_target_for_coverage_fastcov)
+
+    set(options NO_DEMANGLE SKIP_HTML)
+    set(oneValueArgs BASE_DIRECTORY NAME)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES FASTCOV_ARGS GENHTML_ARGS POST_CMD)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT FASTCOV_PATH)
+        message(FATAL_ERROR "fastcov not found! Aborting...")
+    endif()
+
+    if(NOT Coverage_SKIP_HTML AND NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif()
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    # Collect excludes (Patterns, not paths, for fastcov)
+    set(FASTCOV_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_FASTCOV_EXCLUDES})
+        list(APPEND FASTCOV_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES FASTCOV_EXCLUDES)
+
+    # Conditional arguments
+    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
+        set(GENHTML_EXTRA_ARGS "--demangle-cpp")
+    endif()
+
+    # Set up commands which will be run to generate coverage data
+    set(FASTCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
+
+    set(FASTCOV_CAPTURE_CMD ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
+        --search-directory ${BASEDIR}
+        --process-gcno
+        --output ${Coverage_NAME}.json
+        --exclude ${FASTCOV_EXCLUDES}
+        --exclude ${FASTCOV_EXCLUDES}
+    )
+    
+    set(FASTCOV_CONVERT_CMD ${FASTCOV_PATH}
+        -C ${Coverage_NAME}.json --lcov --output ${Coverage_NAME}.info
+    )
+
+    if(Coverage_SKIP_HTML)
+        set(FASTCOV_HTML_CMD ";")
+    else()
+        set(FASTCOV_HTML_CMD ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS}
+            -o ${Coverage_NAME} ${Coverage_NAME}.info
+        )
+    endif()
+
+    set(FASTCOV_POST_CMD ";")
+    if(Coverage_POST_CMD)
+        set(FASTCOV_POST_CMD ${Coverage_POST_CMD})
+    endif()
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Code coverage commands for target ${Coverage_NAME} (fastcov):")
+
+        message("   Running tests:")
+        string(REPLACE ";" " " FASTCOV_EXEC_TESTS_CMD_SPACED "${FASTCOV_EXEC_TESTS_CMD}")
+        message("     ${FASTCOV_EXEC_TESTS_CMD_SPACED}")
+
+        message("   Capturing fastcov counters and generating report:")
+        string(REPLACE ";" " " FASTCOV_CAPTURE_CMD_SPACED "${FASTCOV_CAPTURE_CMD}")
+        message("     ${FASTCOV_CAPTURE_CMD_SPACED}")
+
+        message("   Converting fastcov .json to lcov .info:")
+        string(REPLACE ";" " " FASTCOV_CONVERT_CMD_SPACED "${FASTCOV_CONVERT_CMD}")
+        message("     ${FASTCOV_CONVERT_CMD_SPACED}")
+
+        if(NOT Coverage_SKIP_HTML)
+            message("   Generating HTML report: ")
+            string(REPLACE ";" " " FASTCOV_HTML_CMD_SPACED "${FASTCOV_HTML_CMD}")
+            message("     ${FASTCOV_HTML_CMD_SPACED}")
+        endif()
+        if(Coverage_POST_CMD)
+            message("   Running post command: ")
+            string(REPLACE ";" " " FASTCOV_POST_CMD_SPACED "${FASTCOV_POST_CMD}")
+            message("     ${FASTCOV_POST_CMD_SPACED}")
+        endif()
+    endif()
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+
+        # Cleanup fastcov
+        COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
+            --search-directory ${BASEDIR}
+            --zerocounters
+
+        COMMAND ${FASTCOV_EXEC_TESTS_CMD}
+        COMMAND ${FASTCOV_CAPTURE_CMD}
+        COMMAND ${FASTCOV_CONVERT_CMD}
+        COMMAND ${FASTCOV_HTML_CMD}
+        COMMAND ${FASTCOV_POST_CMD}
+
+        # Set output files as GENERATED (will be removed on 'make clean')
+        BYPRODUCTS
+             ${Coverage_NAME}.info
+             ${Coverage_NAME}.json
+             ${Coverage_NAME}/index.html  # report directory
+
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Resetting code coverage counters to zero. Processing code coverage counters and generating report."
+    )
+
+    set(INFO_MSG "fastcov code coverage info report saved in ${Coverage_NAME}.info and ${Coverage_NAME}.json.")
+    if(NOT Coverage_SKIP_HTML)
+        string(APPEND INFO_MSG " Open ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html in your browser to view the coverage report.")
+    endif()
+    # Show where to find the fastcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E echo ${INFO_MSG}
+    )
+
+endfunction() # setup_target_for_coverage_fastcov
+
+function(append_coverage_compiler_flags)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # append_coverage_compiler_flags
+
+# Setup coverage for specific library
+function(append_coverage_compiler_flags_to_target name)
+    target_compile_options(${name}
+        PRIVATE ${COVERAGE_COMPILER_FLAGS})
+endfunction()

cmake/cmake-modules/bilke/LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake

@@ -0,0 +1,284 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the working tree (--dirty option),
+# and adjusting the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+#  git_local_changes(<var>)
+#
+# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
+# Uses the return code of "git diff-index --quiet HEAD --".
+# Does not regard untracked files.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+#
+# Copyright 2009-2013, Iowa State University.
+# Copyright 2013-2020, Ryan Pavlik
+# Copyright 2013-2020, Contributors
+# SPDX-License-Identifier: BSL-1.0
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+    return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+# Function _git_find_closest_git_dir finds the next closest .git directory
+# that is part of any directory in the path defined by _start_dir.
+# The result is returned in the parent scope variable whose name is passed
+# as variable _git_dir_var. If no .git directory can be found, the
+# function returns an empty string via _git_dir_var.
+#
+# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
+# neither foo nor bar contain a file/directory .git. This wil return
+# C:/bla/.git
+#
+function(_git_find_closest_git_dir _start_dir _git_dir_var)
+    set(cur_dir "${_start_dir}")
+    set(git_dir "${_start_dir}/.git")
+    while(NOT EXISTS "${git_dir}")
+        # .git dir not found, search parent directories
+        set(git_previous_parent "${cur_dir}")
+        get_filename_component(cur_dir "${cur_dir}" DIRECTORY)
+        if(cur_dir STREQUAL git_previous_parent)
+            # We have reached the root directory, we are not in git
+            set(${_git_dir_var}
+                ""
+                PARENT_SCOPE)
+            return()
+        endif()
+        set(git_dir "${cur_dir}/.git")
+    endwhile()
+    set(${_git_dir_var}
+        "${git_dir}"
+        PARENT_SCOPE)
+endfunction()
+
+function(get_git_head_revision _refspecvar _hashvar)
+    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
+
+    if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
+    else()
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE)
+    endif()
+    if(NOT "${GIT_DIR}" STREQUAL "")
+        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
+             "${GIT_DIR}")
+        if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
+            # We've gone above the CMake root dir.
+            set(GIT_DIR "")
+        endif()
+    endif()
+    if("${GIT_DIR}" STREQUAL "")
+        set(${_refspecvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        set(${_hashvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # Check if the current source dir is a git submodule or a worktree.
+    # In both cases .git is a file instead of a directory.
+    #
+    if(NOT IS_DIRECTORY ${GIT_DIR})
+        # The following git command will return a non empty string that
+        # points to the super project working tree if the current
+        # source dir is inside a git submodule.
+        # Otherwise the command will return an empty string.
+        #
+        execute_process(
+            COMMAND "${GIT_EXECUTABLE}" rev-parse
+                    --show-superproject-working-tree
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            OUTPUT_VARIABLE out
+            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(NOT "${out}" STREQUAL "")
+            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
+            file(READ ${GIT_DIR} submodule)
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
+                                 ${submodule})
+            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
+            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
+                                   ABSOLUTE)
+            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+        else()
+            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
+            file(READ ${GIT_DIR} worktree_ref)
+            # The .git directory contains a path to the worktree information directory
+            # inside the parent git repo of the worktree.
+            #
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
+                                 ${worktree_ref})
+            string(STRIP ${git_worktree_dir} git_worktree_dir)
+            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
+            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
+        endif()
+    else()
+        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+    endif()
+    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+    if(NOT EXISTS "${GIT_DATA}")
+        file(MAKE_DIRECTORY "${GIT_DATA}")
+    endif()
+
+    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
+        return()
+    endif()
+    set(HEAD_FILE "${GIT_DATA}/HEAD")
+    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
+
+    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+                   "${GIT_DATA}/grabRef.cmake" @ONLY)
+    include("${GIT_DATA}/grabRef.cmake")
+
+    set(${_refspecvar}
+        "${HEAD_REF}"
+        PARENT_SCOPE)
+    set(${_hashvar}
+        "${HEAD_HASH}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # TODO sanitize
+    #if((${ARGN}" MATCHES "&&") OR
+    #   (ARGN MATCHES "||") OR
+    #   (ARGN MATCHES "\\;"))
+    #   message("Please report the following error to the project!")
+    #   message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+    #endif()
+
+    #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_describe_working_tree _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+    git_describe(out --exact-match ${ARGN})
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_local_changes _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    get_git_head_revision(refspec hash)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(res EQUAL 0)
+        set(${_var}
+            "CLEAN"
+            PARENT_SCOPE)
+    else()
+        set(${_var}
+            "DIRTY"
+            PARENT_SCOPE)
+    endif()
+endfunction()

cmake/cmake-modules/rpavlik/GetGitRevisionDescription.cmake.in

@@ -0,0 +1,43 @@
+#
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright 2009-2012, Iowa State University
+# Copyright 2011-2015, Contributors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+# SPDX-License-Identifier: BSL-1.0
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+    # named branch
+    string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+    if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+        configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+    else()
+        configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+        file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+        if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
+            set(HEAD_HASH "${CMAKE_MATCH_1}")
+        endif()
+    endif()
+else()
+    # detached HEAD
+    configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+    file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+    string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()

cmake/cmake-modules/rpavlik/LICENSES/BSD-3-Clause.txt

@@ -0,0 +1,26 @@
+Copyright (c) <year> <owner>. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cmake/cmake-modules/rpavlik/LICENSES/BSL-1.0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute, execute,
+and transmit the Software, and to prepare derivative works of the Software,
+and to permit third-parties to whom the Software is furnished to do so, all
+subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer, must
+be included in all copies of the Software, in whole or in part, and all derivative
+works of the Software, unless such copies or derivative works are solely in
+the form of machine-executable object code generated by a source language
+processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES
+OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

cmake/cmake-modules/rpavlik/LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

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

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

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

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

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

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

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

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -20,7 +20,9 @@ LinuxLibgpioIF::~LinuxLibgpioIF() {
 ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
   ReturnValue_t result;
   if (gpioCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "LinuxLibgpioIF::addGpios: Invalid cookie" << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
@@ -96,8 +98,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
   std::string& label = gpioByLabel.label;
   struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
   if (chip == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByLabel: Failed to open gpio from gpio "
                  << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
+#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "label: " + label;
@@ -108,8 +112,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId, GpiodRegularB
   std::string& chipname = gpioByChip.chipname;
   struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
   if (chip == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByChip: Failed to open chip " << chipname
                  << ". Gpio ID: " << gpioId << std::endl;
+#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "chipname: " + chipname;
@@ -133,8 +139,10 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,
 
   struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname);
   if (chip == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureGpioByLineName: Failed to open chip " << chipname
                  << ". <Gpio ID: " << gpioId << std::endl;
+#endif
     return RETURN_FAILED;
   }
   std::string failOutput = "line name: " + lineName;
@@ -153,10 +161,12 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   lineNum = regularGpio.lineNum;
   lineHandle = gpiod_chip_get_line(chip, lineNum);
   if (!lineHandle) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open line " << std::endl;
     sif::warning << "GPIO ID: " << gpioId << ", line number: " << lineNum << ", " << failOutput
                  << std::endl;
     sif::warning << "Check if Linux GPIO configuration has changed. " << std::endl;
+#endif
     gpiod_chip_close(chip);
     return RETURN_FAILED;
   }
@@ -175,7 +185,9 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
       break;
     }
     default: {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "LinuxLibgpioIF::configureGpios: Invalid direction specified" << std::endl;
+#endif
       return GPIO_INVALID_INSTANCE;
     }
 
@@ -204,7 +216,9 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
 ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::pullHigh: Unknown GPIO ID " << gpioId << std::endl;
+#endif
     return UNKNOWN_GPIO_ID;
   }
 

hal/src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -210,7 +210,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
-    ReturnValue_t result = gpioComIF->pullLow(gpioId);
+    result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1

hal/src/fsfw_hal/linux/uart/UartComIF.cpp

@@ -314,7 +314,7 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B4000000);
       cfsetospeed(options, B4000000);
       break;
-#endif // ! __APPLE__
+#endif  // ! __APPLE__
     default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;

hal/src/fsfw_hal/stm32h7/devicetest/GyroL3GD20H.h

@@ -10,6 +10,10 @@
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_spi.h"
 
+#ifndef STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION
+#define STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION 1
+#endif
+
 enum class TransferStates { IDLE, WAIT, SUCCESS, FAILURE };
 
 class GyroL3GD20H {

scripts/apply-clang-format.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-if [[ ! -f README.md ]]; then
-	cd ..
-fi
-
-find ./src -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
-find ./hal -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
-find ./tests -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i

scripts/auto-formatter.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+if [[ ! -f README.md ]]; then
+  cd ..
+fi
+
+cmake_fmt="cmake-format"
+file_selectors="-iname CMakeLists.txt"
+if command -v ${cmake_fmt} &> /dev/null; then
+  ${cmake_fmt} -i CMakeLists.txt
+  find ./src ${file_selectors} | xargs ${cmake_fmt}  -i
+else
+  echo "No ${cmake_fmt} tool found, not formatting CMake files"
+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
+else
+  echo "No ${cpp_format} tool found, not formatting C++/C files"
+fi

src/CMakeLists.txt

@@ -1,9 +1,6 @@
-target_include_directories(${LIB_FSFW_NAME} PRIVATE
+target_include_directories(${LIB_FSFW_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
 
-target_include_directories(${LIB_FSFW_NAME} INTERFACE
+target_include_directories(${LIB_FSFW_NAME}
-    ${CMAKE_CURRENT_SOURCE_DIR}
+                           INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
-)
 
 add_subdirectory(fsfw)

src/fsfw/CMakeLists.txt

@@ -1,6 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE version.cpp)
-    version.cpp
-)
 
 # Core
 
@@ -37,22 +35,22 @@ add_subdirectory(tmtcservices)
 # Optional
 
 if(FSFW_ADD_MONITORING)
-add_subdirectory(monitoring)
+  add_subdirectory(monitoring)
 endif()
 if(FSFW_ADD_PUS)
-    add_subdirectory(pus)
+  add_subdirectory(pus)
 endif()
 if(FSFW_ADD_TMSTORAGE)
-    add_subdirectory(tmstorage)
+  add_subdirectory(tmstorage)
 endif()
 if(FSFW_ADD_COORDINATES)
-    add_subdirectory(coordinates)
+  add_subdirectory(coordinates)
 endif()
 if(FSFW_ADD_RMAP)
-    add_subdirectory(rmap)
+  add_subdirectory(rmap)
 endif()
 if(FSFW_ADD_DATALINKLAYER)
-    add_subdirectory(datalinklayer)
+  add_subdirectory(datalinklayer)
 endif()
 
 # OSAL

src/fsfw/FSFWVersion.h.in

@@ -1,9 +1,11 @@
 #ifndef FSFW_VERSION_H_
 #define FSFW_VERSION_H_
 
-// Versioning is kept in project CMakeLists.txt file
+// Versioning is managed in project CMakeLists.txt file
-#define FSFW_VERSION_MAJOR @FSFW_VERSION@
+static constexpr int FSFW_VERSION_MAJOR = @FSFW_VERSION@;
-#define FSFW_VERSION_MINOR @FSFW_SUBVERSION@
+static constexpr int FSFW_VERSION_MINOR = @FSFW_SUBVERSION@;
-#define FSFW_VERSION_REVISION @FSFW_REVISION@
+static constexpr int FSFW_VERSION_REVISION = @FSFW_REVISION@;
+// Also contains CST (Commits since tag) information
+static const char FSFW_VCS_INFO[] = "@FSFW_VCS_INFO@";
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/action/ActionHelper.cpp

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

src/fsfw/action/ActionHelper.h

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

src/fsfw/action/ActionMessage.cpp

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

src/fsfw/action/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-    PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE ActionHelper.cpp ActionMessage.cpp
-        ActionHelper.cpp
+                           CommandActionHelper.cpp SimpleActionHelper.cpp)
-        ActionMessage.cpp
-        CommandActionHelper.cpp
-        SimpleActionHelper.cpp
-)

src/fsfw/action/CommandActionHelper.cpp

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

src/fsfw/action/CommandActionHelper.h

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

src/fsfw/action/CommandsActionsIF.h

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

src/fsfw/action/HasActionsIF.h

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

src/fsfw/action/SimpleActionHelper.cpp

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

src/fsfw/action/SimpleActionHelper.h

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

src/fsfw/cfdp/CMakeLists.txt

@@ -1,7 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE CFDPHandler.cpp CFDPMessage.cpp)
-    CFDPHandler.cpp
-    CFDPMessage.cpp
-)
 
 add_subdirectory(pdu)
 add_subdirectory(tlv)

src/fsfw/cfdp/pdu/AckInfo.cpp

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

src/fsfw/cfdp/pdu/AckInfo.h

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

src/fsfw/cfdp/pdu/AckPduDeserializer.h

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

src/fsfw/cfdp/pdu/AckPduSerializer.h

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

src/fsfw/cfdp/pdu/CMakeLists.txt

@@ -1,32 +1,30 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    PduConfig.cpp
+  ${LIB_FSFW_NAME}
-    VarLenField.cpp
+  PRIVATE PduConfig.cpp
-    HeaderSerializer.cpp
+          VarLenField.cpp
-    HeaderDeserializer.cpp
+          HeaderSerializer.cpp
-    FileDirectiveDeserializer.cpp
+          HeaderDeserializer.cpp
-    FileDirectiveSerializer.cpp
+          FileDirectiveDeserializer.cpp
- 
+          FileDirectiveSerializer.cpp
-    AckInfo.cpp
+          AckInfo.cpp
-    AckPduSerializer.cpp
+          AckPduSerializer.cpp
-    AckPduDeserializer.cpp
+          AckPduDeserializer.cpp
-    EofInfo.cpp
+          EofInfo.cpp
-    EofPduSerializer.cpp
+          EofPduSerializer.cpp
-    EofPduDeserializer.cpp
+          EofPduDeserializer.cpp
-    NakInfo.cpp
+          NakInfo.cpp
-    NakPduSerializer.cpp
+          NakPduSerializer.cpp
-    NakPduDeserializer.cpp
+          NakPduDeserializer.cpp
-    FinishedInfo.cpp
+          FinishedInfo.cpp
-    FinishedPduSerializer.cpp
+          FinishedPduSerializer.cpp
-    FinishedPduDeserializer.cpp
+          FinishedPduDeserializer.cpp
-    MetadataInfo.cpp
+          MetadataInfo.cpp
-    MetadataPduSerializer.cpp
+          MetadataPduSerializer.cpp
-    MetadataPduDeserializer.cpp
+          MetadataPduDeserializer.cpp
-    KeepAlivePduSerializer.cpp
+          KeepAlivePduSerializer.cpp
-    KeepAlivePduDeserializer.cpp
+          KeepAlivePduDeserializer.cpp
-    PromptPduSerializer.cpp
+          PromptPduSerializer.cpp
-    PromptPduDeserializer.cpp
+          PromptPduDeserializer.cpp
-
+          FileDataSerializer.cpp
-    FileDataSerializer.cpp
+          FileDataDeserializer.cpp
-    FileDataDeserializer.cpp
+          FileDataInfo.cpp)
-    FileDataInfo.cpp
-)

src/fsfw/cfdp/tlv/CMakeLists.txt

@@ -1,10 +1,10 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    EntityIdTlv.cpp
+  ${LIB_FSFW_NAME}
-    FilestoreRequestTlv.cpp
+  PRIVATE EntityIdTlv.cpp
-    FilestoreResponseTlv.cpp
+          FilestoreRequestTlv.cpp
-    Lv.cpp
+          FilestoreResponseTlv.cpp
-    Tlv.cpp
+          Lv.cpp
-    FlowLabelTlv.cpp
+          Tlv.cpp
-    MessageToUserTlv.cpp
+          FlowLabelTlv.cpp
-    FaultHandlerOverrideTlv.cpp
+          MessageToUserTlv.cpp
-)
+          FaultHandlerOverrideTlv.cpp)

src/fsfw/container/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE SharedRingBuffer.cpp
-    PRIVATE 
+                                        SimpleRingBuffer.cpp)
-        SharedRingBuffer.cpp
-        SimpleRingBuffer.cpp
-)

src/fsfw/container/FIFOBase.tpp

@@ -5,89 +5,88 @@
 #error Include FIFOBase.h before FIFOBase.tpp!
 #endif
 
-template<typename T>
+template <typename T>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity)
-        maxCapacity(maxCapacity), values(values){};
+    : maxCapacity(maxCapacity), values(values){};
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
-    if (full()) {
+  if (full()) {
-        return FULL;
+    return FULL;
-    } else {
+  } else {
-        values[writeIndex] = value;
+    values[writeIndex] = value;
-        writeIndex = next(writeIndex);
+    writeIndex = next(writeIndex);
-        ++currentSize;
+    ++currentSize;
-        return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
-    }
+  }
 };
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-    if (empty()) {
+  if (empty()) {
-        return EMPTY;
+    return EMPTY;
-    } else {
+  } else {
-        if (value == nullptr){
+    if (value == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        *value = values[readIndex];
-        readIndex = next(readIndex);
-        --currentSize;
-        return HasReturnvaluesIF::RETURN_OK;
     }
+    *value = values[readIndex];
+    readIndex = next(readIndex);
+    --currentSize;
+    return HasReturnvaluesIF::RETURN_OK;
+  }
 };
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-    if(empty()) {
+  if (empty()) {
-        return EMPTY;
+    return EMPTY;
-    } else {
+  } else {
-        if (value == nullptr){
+    if (value == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        *value = values[readIndex];
-        return HasReturnvaluesIF::RETURN_OK;
     }
+    *value = values[readIndex];
+    return HasReturnvaluesIF::RETURN_OK;
+  }
 };
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t FIFOBase<T>::pop() {
-    T value;
+  T value;
-    return this->retrieve(&value);
+  return this->retrieve(&value);
 };
 
-template<typename T>
+template <typename T>
 inline bool FIFOBase<T>::empty() {
-    return (currentSize == 0);
+  return (currentSize == 0);
 };
 
-template<typename T>
+template <typename T>
 inline bool FIFOBase<T>::full() {
-    return (currentSize == maxCapacity);
+  return (currentSize == maxCapacity);
 }
 
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::size() {
-    return currentSize;
+  return currentSize;
 }
 
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::next(size_t current) {
-    ++current;
+  ++current;
-    if (current == maxCapacity) {
+  if (current == maxCapacity) {
-        current = 0;
+    current = 0;
-    }
+  }
-    return current;
+  return current;
 }
 
-template<typename T>
+template <typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-    return maxCapacity;
+  return maxCapacity;
 }
 
-
+template <typename T>
-template<typename T>
+inline void FIFOBase<T>::setContainer(T* data) {
-inline void FIFOBase<T>::setContainer(T *data) {
+  this->values = data;
-    this->values = data;
 }
 
 #endif

src/fsfw/container/FixedArrayList.h

@@ -12,6 +12,7 @@ template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
   static_assert(MAX_SIZE <= std::numeric_limits<count_t>::max(),
                 "count_t is not large enough to hold MAX_SIZE");
+
  private:
   T data[MAX_SIZE];
 

src/fsfw/container/FixedOrderedMultimap.tpp

@@ -1,109 +1,109 @@
 #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 
-
+template <typename key_t, typename T, typename KEY_COMPARE>
-template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value,
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
+                                                                         Iterator *storedValue) {
-    if (_size == theMap.maxSize()) {
+  if (_size == theMap.maxSize()) {
-        return MAP_FULL;
+    return MAP_FULL;
-    }
+  }
-    size_t position = findNicePlace(key);
+  size_t position = findNicePlace(key);
-    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+  memmove(static_cast<void *>(&theMap[position + 1]), static_cast<void *>(&theMap[position]),
-            (_size - position) * sizeof(std::pair<key_t,T>));
+          (_size - position) * sizeof(std::pair<key_t, T>));
-    theMap[position].first = key;
+  theMap[position].first = key;
-    theMap[position].second = value;
+  theMap[position].second = value;
-    ++_size;
+  ++_size;
-    if (storedValue != nullptr) {
+  if (storedValue != nullptr) {
-        *storedValue = Iterator(&theMap[position]);
+    *storedValue = Iterator(&theMap[position]);
-    }
+  }
-    return HasReturnvaluesIF::RETURN_OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
-template<typename key_t, typename T, typename KEY_COMPARE>
+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) {
-    return insert(pair.first, pair.second);
+  return insert(pair.first, pair.second);
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+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;
+  ReturnValue_t result = KEY_DOES_NOT_EXIST;
-    if (findFirstIndex(key) < _size) {
+  if (findFirstIndex(key) < _size) {
-        result = HasReturnvaluesIF::RETURN_OK;
+    result = HasReturnvaluesIF::RETURN_OK;
-    }
+  }
-    return result;
+  return result;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-    size_t i;
+  size_t i;
-    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+  if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
+    return KEY_DOES_NOT_EXIST;
-    }
+  }
-    removeFromPosition(i);
+  removeFromPosition(i);
-    if (*iter != begin()) {
+  if (*iter != begin()) {
-        (*iter)--;
+    (*iter)--;
-    } else {
+  } else {
-        *iter = begin();
+    *iter = begin();
-    }
+  }
-    return HasReturnvaluesIF::RETURN_OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-    size_t i;
+  size_t i;
-    if ((i = findFirstIndex(key)) >= _size) {
+  if ((i = findFirstIndex(key)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
+    return KEY_DOES_NOT_EXIST;
-    }
+  }
-    do {
+  do {
-        removeFromPosition(i);
+    removeFromPosition(i);
-        i = findFirstIndex(key, i);
+    i = findFirstIndex(key, i);
-    } while (i < _size);
+  } while (i < _size);
-    return HasReturnvaluesIF::RETURN_OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+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);
+  ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
+    return result;
-    }
+  }
-    *value = &theMap[findFirstIndex(key)].second;
+  *value = &theMap[findFirstIndex(key)].second;
-    return HasReturnvaluesIF::RETURN_OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key,
-    if (startAt >= _size) {
+                                                                          size_t startAt) const {
-        return startAt + 1;
+  if (startAt >= _size) {
+    return startAt + 1;
+  }
+  size_t i = startAt;
+  for (i = startAt; i < _size; ++i) {
+    if (theMap[i].first == key) {
+      return i;
     }
-    size_t i = startAt;
+  }
-    for (i = startAt; i < _size; ++i) {
+  return i;
-        if (theMap[i].first == key) {
-            return i;
-        }
-    }
-    return i;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-    size_t i = 0;
+  size_t i = 0;
-    for (i = 0; i < _size; ++i) {
+  for (i = 0; i < _size; ++i) {
-        if (myComp(key, theMap[i].first)) {
+    if (myComp(key, theMap[i].first)) {
-            return i;
+      return i;
-        }
     }
-    return i;
+  }
+  return i;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
+template <typename key_t, typename T, typename KEY_COMPARE>
 inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-    if (_size <= position) {
+  if (_size <= position) {
-        return;
+    return;
-    }
+  }
-    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+  memmove(static_cast<void *>(&theMap[position]), static_cast<void *>(&theMap[position + 1]),
-            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+          (_size - position - 1) * sizeof(std::pair<key_t, T>));
-    --_size;
+  --_size;
 }
 
-
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

src/fsfw/controller/CMakeLists.txt

@@ -1,4 +1,2 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(${LIB_FSFW_NAME} PRIVATE ControllerBase.cpp
-    ControllerBase.cpp
+                                        ExtendedControllerBase.cpp)
-    ExtendedControllerBase.cpp
-)

src/fsfw/controller/ControllerBase.cpp

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

src/fsfw/controller/ControllerBase.h

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

src/fsfw/controller/ExtendedControllerBase.cpp

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

src/fsfw/controller/ExtendedControllerBase.h

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

src/fsfw/coordinates/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE CoordinateTransformations.cpp
-	PRIVATE 
+                                        Sgp4Propagator.cpp)
-		CoordinateTransformations.cpp
-		Sgp4Propagator.cpp
-)

src/fsfw/datalinklayer/CMakeLists.txt

@@ -1,12 +1,11 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		Clcw.cpp
+  PRIVATE Clcw.cpp
-		DataLinkLayer.cpp
+          DataLinkLayer.cpp
-		Farm1StateLockout.cpp
+          Farm1StateLockout.cpp
-		Farm1StateOpen.cpp
+          Farm1StateOpen.cpp
-		Farm1StateWait.cpp
+          Farm1StateWait.cpp
-		MapPacketExtraction.cpp
+          MapPacketExtraction.cpp
-		TcTransferFrame.cpp
+          TcTransferFrame.cpp
-		TcTransferFrameLocal.cpp
+          TcTransferFrameLocal.cpp
-		VirtualChannelReception.cpp
+          VirtualChannelReception.cpp)
-)

src/fsfw/datapool/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE PoolDataSetBase.cpp PoolEntry.cpp)
-	PoolDataSetBase.cpp
-	PoolEntry.cpp
-)

src/fsfw/datapool/DataSetIF.h

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

src/fsfw/datapool/PoolDataSetBase.cpp

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

src/fsfw/datapool/PoolDataSetBase.h

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

src/fsfw/datapool/PoolEntry.cpp

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

src/fsfw/datapool/PoolEntry.h

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

src/fsfw/datapool/PoolEntryIF.h

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

src/fsfw/datapool/PoolReadGuard.h

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

src/fsfw/datapool/PoolVarList.h

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

src/fsfw/datapool/PoolVariableIF.h

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

src/fsfw/datapool/ReadCommitIF.h

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

src/fsfw/datapool/SharedDataSetIF.h

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

src/fsfw/datapoollocal/AccessLocalPoolF.h

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

src/fsfw/datapoollocal/CMakeLists.txt

@@ -1,10 +1,6 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		LocalDataPoolManager.cpp
+  PRIVATE LocalDataPoolManager.cpp LocalDataSet.cpp LocalPoolDataSetBase.cpp
-		LocalDataSet.cpp
+          LocalPoolObjectBase.cpp SharedLocalDataSet.cpp)
-		LocalPoolDataSetBase.cpp
-		LocalPoolObjectBase.cpp
-		SharedLocalDataSet.cpp
-)
 
-add_subdirectory(internal)
+add_subdirectory(internal)

src/fsfw/datapoollocal/HasLocalDataPoolIF.h

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

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

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

src/fsfw/datapoollocal/LocalDataPoolManager.h

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

src/fsfw/datapoollocal/LocalPoolVariable.tpp

@@ -5,205 +5,189 @@
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif
 
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
+template <typename T>
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet,
+                                               pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
+                          setReadWriteMode) {}
 
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                uint32_t timeoutMs) {
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+  if (hkManager == nullptr) {
-                dataSet, setReadWriteMode){}
+    return readWithoutLock();
-
+  }
-
+  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-template<typename T>
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-inline ReturnValue_t LocalPoolVariable<T>::read(
+  if (result != HasReturnvaluesIF::RETURN_OK) {
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    if(hkManager == nullptr) {
-        return readWithoutLock();
-    }
-    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    result = readWithoutLock();
-    mutex->unlockMutex();
     return result;
+  }
+  result = readWithoutLock();
+  mutex->unlockMutex();
+  return result;
 }
 
-template<typename T>
+template <typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
 
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
-                false, ownerObjectId, localPoolId);
-        return result;
-    }
-
-    this->value = *(poolEntry->getDataPtr());
-    this->valid = poolEntry->getValid();
-    return RETURN_OK;
-}
-
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    this->setValid(setValid);
-    return commit(timeoutType, timeoutMs);
-}
-
-template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    if(hkManager == nullptr) {
-        return commitWithoutLock();
-    }
-    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    result = commitWithoutLock();
-    mutex->unlockMutex();
     return result;
+  }
+
+  this->value = *(poolEntry->getDataPtr());
+  this->valid = poolEntry->getValid();
+  return RETURN_OK;
 }
 
-template<typename T>
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid, MutexIF::TimeoutType timeoutType,
+                                                  uint32_t timeoutMs) {
+  this->setValid(setValid);
+  return commit(timeoutType, timeoutMs);
+}
+
+template <typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(MutexIF::TimeoutType timeoutType,
+                                                  uint32_t timeoutMs) {
+  if (hkManager == nullptr) {
+    return commitWithoutLock();
+  }
+  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = commitWithoutLock();
+  mutex->unlockMutex();
+  return result;
+}
+
+template <typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
 
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVariable", result,
+    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
-                false, ownerObjectId, localPoolId);
+    return result;
-        return result;
+  }
-    }
 
-    *(poolEntry->getDataPtr()) = this->value;
+  *(poolEntry->getDataPtr()) = this->value;
-    poolEntry->setValid(this->valid);
+  poolEntry->setValid(this->valid);
-    return RETURN_OK;
+  return RETURN_OK;
 }
 
-template<typename T>
+template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::serialize(
-        size_t* size, const size_t max_size,
+    uint8_t** buffer, size_t* size, const size_t max_size,
-        SerializeIF::Endianness streamEndianness) const {
+    SerializeIF::Endianness streamEndianness) const {
-    return SerializeAdapter::serialize(&value,
+  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
-            buffer, size ,max_size, streamEndianness);
 }
 
-template<typename T>
+template <typename T>
 inline size_t LocalPoolVariable<T>::getSerializedSize() const {
-    return SerializeAdapter::getSerializedSize(&value);
+  return SerializeAdapter::getSerializedSize(&value);
 }
 
-template<typename T>
+template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
-        size_t* size, SerializeIF::Endianness streamEndianness) {
+                                                       SerializeIF::Endianness streamEndianness) {
-    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+  return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T>
+template <typename T>
-inline std::ostream& operator<< (std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<T>& var) {
-        const LocalPoolVariable<T> &var) {
+  out << var.value;
-    out << var.value;
+  return out;
-    return out;
 }
 #endif
 
-template<typename T>
+template <typename T>
 inline LocalPoolVariable<T>::operator T() const {
-    return value;
+  return value;
 }
 
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(const T& newValue) {
-        const T& newValue) {
+  value = newValue;
-    value = newValue;
+  return *this;
-    return *this;
 }
 
-template<typename T>
+template <typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(
-        const LocalPoolVariable<T>& newPoolVariable) {
+    const LocalPoolVariable<T>& newPoolVariable) {
-    value = newPoolVariable.value;
+  value = newPoolVariable.value;
-    return *this;
+  return *this;
 }
 
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator ==(
+inline bool LocalPoolVariable<T>::operator==(const LocalPoolVariable<T>& other) const {
-        const LocalPoolVariable<T> &other) const {
+  return this->value == other.value;
-    return this->value == other.value;
 }
 
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
+inline bool LocalPoolVariable<T>::operator==(const T& other) const {
-    return this->value == other;
+  return this->value == other;
 }
 
-
+template <typename T>
-template<typename T>
+inline bool LocalPoolVariable<T>::operator!=(const LocalPoolVariable<T>& other) const {
-inline bool LocalPoolVariable<T>::operator !=(
+  return not(*this == other);
-        const LocalPoolVariable<T> &other) const {
-    return not (*this == other);
 }
 
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
+inline bool LocalPoolVariable<T>::operator!=(const T& other) const {
-    return not (*this == other);
+  return not(*this == other);
 }
 
-
+template <typename T>
-template<typename T>
+inline bool LocalPoolVariable<T>::operator<(const LocalPoolVariable<T>& other) const {
-inline bool LocalPoolVariable<T>::operator <(
+  return this->value < other.value;
-        const LocalPoolVariable<T> &other) const {
-    return this->value < other.value;
 }
 
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator <(const T &other) const {
+inline bool LocalPoolVariable<T>::operator<(const T& other) const {
-    return this->value < other;
+  return this->value < other;
 }
 
-
+template <typename T>
-template<typename T>
+inline bool LocalPoolVariable<T>::operator>(const LocalPoolVariable<T>& other) const {
-inline bool LocalPoolVariable<T>::operator >(
+  return not(*this < other);
-        const LocalPoolVariable<T> &other) const {
-    return not (*this < other);
 }
 
-template<typename T>
+template <typename T>
-inline bool LocalPoolVariable<T>::operator >(const T &other) const {
+inline bool LocalPoolVariable<T>::operator>(const T& other) const {
-    return not (*this < other);
+  return not(*this < other);
 }
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */

src/fsfw/datapoollocal/LocalPoolVector.tpp

@@ -5,174 +5,172 @@
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+                                                       DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode):
+                                                       pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                       DataSetIF* dataSet,
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+                                                       pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                       pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                dataSet, setReadWriteMode) {}
+                          setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                          uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return readWithoutLock();
+  return readWithoutLock();
 }
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
 
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    memset(this->value, 0, vectorSize * sizeof(T));
+  memset(this->value, 0, vectorSize * sizeof(T));
 
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
-                localPoolId);
+    return result;
-        return result;
+  }
-    }
+  std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+  this->valid = poolEntry->getValid();
-    this->valid = poolEntry->getValid();
+  return RETURN_OK;
-    return RETURN_OK;
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                            MutexIF::TimeoutType timeoutType,
-    this->setValid(valid);
+                                                            uint32_t timeoutMs) {
-    return commit(timeoutType, timeoutMs);
+  this->setValid(valid);
+  return commit(timeoutType, timeoutMs);
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(MutexIF::TimeoutType timeoutType,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                            uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return commitWithoutLock();
+  return commitWithoutLock();
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
+  PoolEntry<T>* poolEntry = nullptr;
-    PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-            &poolEntry);
+  if (result != RETURN_OK) {
-    if(result != RETURN_OK) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
-        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
-                localPoolId);
-        return result;
-    }
-    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-    poolEntry->setValid(this->valid);
-    return RETURN_OK;
-}
-
-template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
-    if(i < vectorSize) {
-        return value[i];
-    }
-    // If this happens, I have to set some value. I consider this
-    // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-            " last value!" << std::endl;
-#else
-    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-            " last value!\n");
-#endif
-    return value[vectorSize - 1];
-}
-
-template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
-    if(i < vectorSize) {
-        return value[i];
-    }
-    // If this happens, I have to set some value. I consider this
-    // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-            " last value!" << std::endl;
-#else
-    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-            " last value!\n");
-#endif
-    return value[vectorSize - 1];
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    for (uint16_t i = 0; i < vectorSize; i++) {
-        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-                maxSize, streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            break;
-        }
-    }
     return result;
+  }
+  std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+  poolEntry->setValid(this->valid);
+  return RETURN_OK;
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator[](size_t i) {
+  if (i < vectorSize) {
+    return value[i];
+  }
+  // If this happens, I have to set some value. I consider this
+  // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+                  " last value!"
+               << std::endl;
+#else
+  sif::printWarning(
+      "LocalPoolVector: Invalid index. Setting or returning"
+      " last value!\n");
+#endif
+  return value[vectorSize - 1];
+}
+
+template <typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator[](size_t i) const {
+  if (i < vectorSize) {
+    return value[i];
+  }
+  // If this happens, I have to set some value. I consider this
+  // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+                  " last value!"
+               << std::endl;
+#else
+  sif::printWarning(
+      "LocalPoolVector: Invalid index. Setting or returning"
+      " last value!\n");
+#endif
+  return value[vectorSize - 1];
+}
+
+template <typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(
+    uint8_t** buffer, size_t* size, size_t maxSize,
+    SerializeIF::Endianness streamEndianness) const {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      break;
+    }
+  }
+  return result;
+}
+
+template <typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-    return vectorSize * SerializeAdapter::getSerializedSize(value);
+  return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-        const uint8_t** buffer, size_t* size,
+    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
-        SerializeIF::Endianness streamEndianness) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
-    for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
-        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+    if (result != HasReturnvaluesIF::RETURN_OK) {
-                streamEndianness);
+      break;
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            break;
-        }
     }
-    return result;
+  }
+  return result;
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline std::ostream& operator<< (std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
-        const LocalPoolVector<T, vectorSize> &var) {
+  out << "Vector: [";
-    out << "Vector: [";
+  for (int i = 0; i < vectorSize; i++) {
-    for(int i = 0;i < vectorSize; i++) {
+    out << var.value[i];
-        out << var.value[i];
+    if (i < vectorSize - 1) {
-        if(i < vectorSize - 1) {
+      out << ", ";
-            out << ", ";
-        }
     }
-    out << "]";
+  }
-    return out;
+  out << "]";
+  return out;
 }
 #endif
 

src/fsfw/datapoollocal/internal/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE HasLocalDpIFUserAttorney.cpp
-	PRIVATE 
+                                        HasLocalDpIFManagerAttorney.cpp)
-		HasLocalDpIFUserAttorney.cpp
-		HasLocalDpIFManagerAttorney.cpp
-)

src/fsfw/devicehandlers/CMakeLists.txt

@@ -1,11 +1,10 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		AssemblyBase.cpp
+  PRIVATE AssemblyBase.cpp
-		ChildHandlerBase.cpp
+          ChildHandlerBase.cpp
-		ChildHandlerFDIR.cpp
+          ChildHandlerFDIR.cpp
-		DeviceHandlerBase.cpp
+          DeviceHandlerBase.cpp
-		DeviceHandlerFailureIsolation.cpp
+          DeviceHandlerFailureIsolation.cpp
-		DeviceHandlerMessage.cpp
+          DeviceHandlerMessage.cpp
-		DeviceTmReportingWrapper.cpp
+          DeviceTmReportingWrapper.cpp
-		HealthDevice.cpp
+          HealthDevice.cpp)
-)

src/fsfw/devicehandlers/DeviceHandlerBase.h

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

src/fsfw/events/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(${LIB_FSFW_NAME} PRIVATE EventManager.cpp EventMessage.cpp)
-    EventManager.cpp
-    EventMessage.cpp
-)
 
 add_subdirectory(eventmatching)

src/fsfw/events/eventmatching/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE EventIdRangeMatcher.cpp EventMatchTree.cpp
-		EventIdRangeMatcher.cpp
+                           ReporterRangeMatcher.cpp SeverityRangeMatcher.cpp)
-		EventMatchTree.cpp
-		ReporterRangeMatcher.cpp
-		SeverityRangeMatcher.cpp
-)

src/fsfw/events/fwSubsystemIdRanges.h

@@ -27,6 +27,7 @@ enum : uint8_t {
   PUS_SERVICE_6 = 86,
   PUS_SERVICE_8 = 88,
   PUS_SERVICE_9 = 89,
+  PUS_SERVICE_11 = 91,
   PUS_SERVICE_17 = 97,
   PUS_SERVICE_23 = 103,
   MGM_LIS3MDL = 106,

src/fsfw/fdir/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE EventCorrelation.cpp FailureIsolationBase.cpp
-		EventCorrelation.cpp
+                           FaultCounter.cpp)
-		FailureIsolationBase.cpp
-		FaultCounter.cpp
-)

src/fsfw/globalfunctions/CMakeLists.txt

@@ -1,13 +1,12 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		arrayprinter.cpp
+  PRIVATE arrayprinter.cpp
-		AsciiConverter.cpp
+          AsciiConverter.cpp
-		CRC.cpp
+          CRC.cpp
-		DleEncoder.cpp
+          DleEncoder.cpp
-		PeriodicOperationDivider.cpp
+          PeriodicOperationDivider.cpp
-		timevalOperations.cpp
+          timevalOperations.cpp
-		Type.cpp
+          Type.cpp
-		bitutility.cpp
+          bitutility.cpp)
-)
 
 add_subdirectory(math)

src/fsfw/globalfunctions/math/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE QuaternionOperations.cpp)
-	PRIVATE 
-		QuaternionOperations.cpp
-)

src/fsfw/health/CMakeLists.txt

@@ -1,6 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE HealthHelper.cpp HealthMessage.cpp
-	PRIVATE 
+                                        HealthTable.cpp)
-		HealthHelper.cpp
-		HealthMessage.cpp
-		HealthTable.cpp	
-)

src/fsfw/health/HasHealthIF.h

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

src/fsfw/housekeeping/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE HousekeepingMessage.cpp
-	PRIVATE 
+                                        PeriodicHousekeepingHelper.cpp)
-		HousekeepingMessage.cpp
-		PeriodicHousekeepingHelper.cpp
-)

src/fsfw/housekeeping/HousekeepingSnapshot.h

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

src/fsfw/internalerror/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE InternalErrorReporter.cpp)
-	PRIVATE 
-		InternalErrorReporter.cpp
-)

src/fsfw/ipc/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    CommandMessage.cpp
+  ${LIB_FSFW_NAME} PRIVATE CommandMessage.cpp CommandMessageCleaner.cpp
-    CommandMessageCleaner.cpp
+                           MessageQueueMessage.cpp MessageQueueBase.cpp)
-    MessageQueueMessage.cpp
-    MessageQueueBase.cpp
-)

src/fsfw/ipc/MessageQueueBase.h

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

src/fsfw/memory/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE MemoryHelper.cpp MemoryMessage.cpp
-    MemoryHelper.cpp
+                                        GenericFileSystemMessage.cpp)
-    MemoryMessage.cpp
-    GenericFileSystemMessage.cpp
-)

src/fsfw/modes/CMakeLists.txt

@@ -1,5 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE ModeHelper.cpp ModeMessage.cpp)
-	PRIVATE 
-		ModeHelper.cpp
-		ModeMessage.cpp
-)

src/fsfw/monitoring/AbsLimitMonitor.h

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

src/fsfw/monitoring/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE LimitViolationReporter.cpp
-	PRIVATE 
+                                        MonitoringMessage.cpp)
-		LimitViolationReporter.cpp
-		MonitoringMessage.cpp
-)

src/fsfw/monitoring/MonitorReporter.h

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