Merge branch 'development' into mueller/refactor-logging-with-fmt

Reviewed-on: KSat/fsfw#27

CMakeLists.txt

@@ -74,7 +74,6 @@ set(FSFW_ETL_LIB_MAJOR_VERSION
 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
@@ -83,6 +82,15 @@ set(FSFW_CATCH2_LIB_VERSION
     v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
     CACHE STRING "Catch2 library exact version requirement")
 
+set(FSFW_FMT_LIB_NAME fmt)
+set(FSFW_FMT_LINK_TARGET fmt::fmt)
+set(FSFW_FMT_LIB_MAJOR_VERSION
+    8
+    CACHE STRING "{fmt} library major version requirement")
+set(FSFW_FMT_LIB_VERSION
+    ${FSFW_FMT_LIB_MAJOR_VERSION}.1.1
+    CACHE STRING "{fmt} 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
@@ -169,11 +177,11 @@ if(FSFW_BUILD_TESTS)
 
   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} "
@@ -183,7 +191,7 @@ if(FSFW_BUILD_TESTS)
   endif()
 endif()
 
-message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
+message(STATUS "${MSG_PREFIX} Finding and/or etl (Embedded Template Library)")
 
 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
@@ -203,6 +211,26 @@ if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
 endif()
 
+message(STATUS "Finding and/or providing {fmt} formatting library")
+
+# Check whether the user has already installed ETL first
+find_package(fmt ${FSFW_FMT_LIB_MAJOR_VERSION} QUIET)
+# Not installed, so use FetchContent to download and provide etl
+if(NOT ${FSFW_FMT_LIB_NAME}_FOUND)
+  message(
+    STATUS
+      "No {fmt} installation was found with find_package. Installing and providing "
+      "{fmt} with FindPackage")
+  include(FetchContent)
+
+  FetchContent_Declare(
+    ${FSFW_FMT_LIB_NAME}
+    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
+    GIT_TAG ${FSFW_FMT_LIB_VERSION})
+
+  list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_FMT_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
@@ -212,7 +240,7 @@ if(FSFW_FETCH_CONTENT_TARGETS)
     add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
   endif()
   if(TARGET Catch2)
-    # Fixes regression -preview4, to be confirmed in later releases Related
+    # Fixes regression -preview4, to be confirmed in later releases. Related
     # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
     set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
   endif()
@@ -445,9 +473,8 @@ target_include_directories(
 
 target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
                                                 ${COMPILER_FLAGS})
-
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET} ${FSFW_FMT_LINK_TARGET})
 
 string(
   CONCAT
@@ -457,6 +484,13 @@ string(
     "Target OSAL: ${FSFW_OS_NAME}\n"
     "######################################################################\n")
 
+# The additional / is important to remove the last character from the path. Note
+# that it does not matter if the OS uses / or \, because we are only saving the
+# path size.
+string(LENGTH "${CMAKE_SOURCE_DIR}/" FSFW_SOURCE_PATH_SIZE)
+target_compile_definitions(
+  ${LIB_FSFW_NAME} PRIVATE "-DFSFW_SOURCE_PATH_SIZE=${FSFW_SOURCE_PATH_SIZE}")
+
 add_custom_command(
   TARGET ${LIB_FSFW_NAME}
   POST_BUILD

misc/archive/ServiceInterfaceStream.h

@@ -57,10 +57,10 @@ class ServiceInterfaceStream : public std::ostream {
 // Forward declaration of interface streams. These should be instantiated in
 // main. They can then be used like std::cout or std::cerr.
 namespace sif {
-extern ServiceInterfaceStream debug;
-extern ServiceInterfaceStream info;
-extern ServiceInterfaceStream warning;
-extern ServiceInterfaceStream error;
+// extern ServiceInterfaceStream debug;
+// extern ServiceInterfaceStream info;
+// extern ServiceInterfaceStream warning;
+// extern ServiceInterfaceStream error;
 }  // namespace sif
 
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */

src/fsfw/action/ActionHelper.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/action.h"
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : owner(setOwner), queueToUse(useThisQueue) {}
@@ -28,13 +28,7 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
   }
 
   if (queueToUse == nullptr) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ActionHelper::initialize: No queue set" << std::endl;
-#else
-    sif::printWarning("ActionHelper::initialize: No queue set\n");
-#endif
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+    FSFW_LOGW("{}", "initialize: No queue set\n");
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -96,14 +90,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   size_t size = 0;
   ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize, &dataPtr);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ActionHelper::reportData: Getting free element from IPC store failed!"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "ActionHelper::reportData: Getting free element from IPC "
-        "store failed!\n");
-#endif
+    FSFW_LOGWT("{}", "reportData: Getting free element from IPC store failed\n");
     return result;
   }
   result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
@@ -138,11 +125,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   store_address_t storeAddress;
   ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ActionHelper::reportData: Adding data to IPC store failed!" << std::endl;
-#else
-    sif::printWarning("ActionHelper::reportData: Adding data to IPC store failed!\n");
-#endif
+    FSFW_LOGWT("{}", "reportData: Adding data to IPC store failed\n");
     return result;
   }
 

src/fsfw/cfdp/CFDPHandler.cpp

@@ -4,6 +4,7 @@
 #include "fsfw/ipc/CommandMessage.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface.h"
 #include "fsfw/storagemanager/storeAddress.h"
 #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
 
@@ -28,13 +29,7 @@ ReturnValue_t CFDPHandler::initialize() {
 }
 
 ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::debug << "CFDPHandler::handleRequest" << std::endl;
-#else
-  sif::printDebug("CFDPHandler::handleRequest\n");
-#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif
+  FSFW_LOGDT("{}", "CFDPHandler::handleRequest\n");
 
   // TODO read out packet from store using storeId
 

src/fsfw/cfdp/pdu/EofPduDeserializer.cpp

@@ -50,17 +50,9 @@ ReturnValue_t EofPduDeserializer::parseData() {
   if (info.getConditionCode() != cfdp::ConditionCode::NO_ERROR) {
     EntityIdTlv* tlvPtr = info.getFaultLoc();
     if (tlvPtr == nullptr) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "EofPduDeserializer::parseData: Ca not deserialize fault location,"
-                      " given TLV pointer invalid"
-                   << std::endl;
-#else
-      sif::printWarning(
-          "EofPduDeserializer::parseData: Ca not deserialize fault location,"
-          " given TLV pointer invalid");
-#endif
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+      FSFW_LOGW("{}",
+                "parseData: Ca not deserialize fault location,"
+                " given TLV pointer invalid\n");
       return HasReturnvaluesIF::RETURN_FAILED;
     }
     result = tlvPtr->deSerialize(&bufPtr, &deserLen, endianness);

src/fsfw/cfdp/pdu/VarLenField.cpp

@@ -7,13 +7,7 @@
 cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, size_t value) : VarLenField() {
   ReturnValue_t result = this->setValue(width, value);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_DISABLE_PRINTOUT == 0
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "cfdp::VarLenField: Setting value failed" << std::endl;
-#else
-    sif::printWarning("cfdp::VarLenField: Setting value failed\n");
-#endif
-#endif
+    FSFW_LOGW("{}", "cfdp::VarLenField: Setting value failed\n");
   }
 }
 

src/fsfw/cfdp/tlv/FilestoreTlvBase.h

@@ -6,7 +6,7 @@
 #include <fsfw/cfdp/tlv/Tlv.h>
 #include <fsfw/cfdp/tlv/TlvIF.h>
 #include <fsfw/serialize/SerializeIF.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/serviceinterface.h>
 
 #include <cstddef>
 #include <cstdint>
@@ -128,17 +128,7 @@ class FilestoreTlvBase : public TlvIF {
   }
 
   void secondFileNameMissing() const {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "FilestoreRequestTlv::deSerialize: Second file name required"
-                    " but TLV pointer not set"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "FilestoreRequestTlv::deSerialize: Second file name required"
-        " but TLV pointer not set\n");
-#endif
-#endif
+    FSFW_LOGWT("{}", "secondFileNameMissing: Second file name required but TLV pointer not set\n");
   }
 
   FilestoreActionCode getActionCode() const { return actionCode; }

src/fsfw/datalinklayer/Clcw.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/datalinklayer/Clcw.h"
 
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 Clcw::Clcw() {
   content.raw = 0;

src/fsfw/datalinklayer/DataLinkLayer.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/datalinklayer/DataLinkLayer.h"
 
 #include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
                              uint8_t set_start_sequence_length, uint16_t set_scid)

src/fsfw/datalinklayer/MapPacketExtraction.cpp

@@ -4,7 +4,7 @@
 
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/tmtcpacket/SpacePacketBase.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"

src/fsfw/datalinklayer/TcTransferFrame.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/datalinklayer/TcTransferFrame.h"
 
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 TcTransferFrame::TcTransferFrame() { frame = nullptr; }
 

src/fsfw/datalinklayer/TcTransferFrameLocal.cpp

@@ -3,7 +3,7 @@
 #include <cstring>
 
 #include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
                                            uint8_t vcId, uint8_t sequenceNumber,

src/fsfw/datalinklayer/VirtualChannelReception.cpp

@@ -8,7 +8,7 @@
 #include "fsfw/datalinklayer/VirtualChannelReception.h"
 
 #include "fsfw/datalinklayer/BCFrame.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
                                                  uint8_t setSlidingWindowWidth)

src/fsfw/datapool/PoolDataSetBase.cpp

@@ -3,7 +3,7 @@
 #include <cstring>
 
 #include "fsfw/datapool/ReadCommitIFAttorney.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
                                  const size_t maxFillCount)
@@ -17,27 +17,15 @@ ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   if (state != States::STATE_SET_UNINITIALISED) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
-#else
-    sif::printError("DataSet::registerVariable: Call made in wrong position.");
-#endif
+    FSFW_LOGW("{}", "registerVariable: Call made in wrong position\n");
     return DataSetIF::DATA_SET_UNINITIALISED;
   }
   if (variable == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
-#else
-    sif::printError("DataSet::registerVariable: Pool variable is nullptr.\n");
-#endif
+    FSFW_LOGW("{}", "registerVariable: Pool variable is nullptr\n");
     return DataSetIF::POOL_VAR_NULL;
   }
   if (fillCount >= maxFillCount) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
-#else
-    sif::printError("DataSet::registerVariable: DataSet is full.\n");
-#endif
+    FSFW_LOGW("{}", "registerVariable: DataSet is full\n");
     return DataSetIF::DATA_SET_FULL;
   }
   registeredVariables[fillCount] = variable;
@@ -59,15 +47,7 @@ ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t l
     state = States::STATE_SET_WAS_READ;
     unlockDataPool();
   } else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "PoolDataSetBase::read: Call made in wrong position. Don't forget to "
-                    "commit member datasets!"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "PoolDataSetBase::read: Call made in wrong position. Don't forget to "
-        "commit member datasets!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+    FSFW_LOGWT("{}", "read: Call made in wrong position. commit call might be missing\n");
     result = SET_WAS_ALREADY_READ;
   }
 

src/fsfw/datapool/PoolEntry.cpp

@@ -4,7 +4,7 @@
 #include <cstring>
 
 #include "fsfw/globalfunctions/arrayprinter.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 template <typename T>
 PoolEntry<T>::PoolEntry(uint8_t len, bool setValid) : length(len), valid(setValid) {
@@ -70,13 +70,7 @@ void PoolEntry<T>::print() {
   } else {
     validString = "Invalid";
   }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "PoolEntry information." << std::endl;
-  sif::info << "PoolEntry validity: " << validString << std::endl;
-#else
-  sif::printInfo("PoolEntry information.\n");
-  sif::printInfo("PoolEntry validity: %s\n", validString);
-#endif
+  FSFW_LOGI("PoolEntry Info. Validity {}\n", validString);
   arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
 }
 

src/fsfw/datapool/PoolReadGuard.h

@@ -1,10 +1,9 @@
 #ifndef FSFW_DATAPOOL_POOLREADHELPER_H_
 #define FSFW_DATAPOOL_POOLREADHELPER_H_
 
-#include <FSFWConfig.h>
-
-#include "../serviceinterface/ServiceInterface.h"
 #include "ReadCommitIF.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
 
 /**
  * @brief 	Helper class to read data sets or pool variables
@@ -18,13 +17,7 @@ class PoolReadGuard {
     if (readObject != nullptr) {
       readResult = readObject->read(timeoutType, mutexTimeout);
       if (readResult != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL == 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "PoolReadHelper: Read failed!" << std::endl;
-#else
-        sif::printError("PoolReadHelper: Read failed!\n");
-#endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        FSFW_LOGW("{}", "ctor: Read failed\n");
       }
     }
   }

src/fsfw/datapoollocal/HasLocalDataPoolIF.h

@@ -6,8 +6,8 @@
 #include "../datapool/PoolEntryIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../ipc/MessageQueueSenderIF.h"
-#include "../serviceinterface/ServiceInterface.h"
 #include "LocalDataPoolManager.h"
+#include "fsfw/serviceinterface.h"
 #include "localPoolDefinitions.h"
 
 class AccessPoolManagerIF;
@@ -166,15 +166,7 @@ class HasLocalDataPoolIF {
    * @return
    */
   virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. "
-                    "Returning nullptr!"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "HasLocalDataPoolIF::getPoolObjectHandle: "
-        "Not overriden. Returning nullptr!\n");
-#endif
+    FSFW_LOGW("{}", "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. Returning nullptr\n");
     return nullptr;
   }
 };

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -3,6 +3,7 @@
 #include <array>
 #include <cmath>
 
+#include "fsfw/FSFW.h"
 #include "fsfw/datapoollocal.h"
 #include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
 #include "fsfw/housekeeping/HousekeepingSetPacket.h"
@@ -21,15 +22,15 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQue
                                            bool appendValidityBuffer)
     : appendValidityBuffer(appendValidityBuffer) {
   if (owner == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager",
-                        HasReturnvaluesIF::RETURN_FAILED, "Invalid supplied owner");
+    printWarningOrError(sif::LogLevel::WARNING, "ctor", HasReturnvaluesIF::RETURN_FAILED,
+                        "Invalid supplied owner");
     return;
   }
   this->owner = owner;
   mutex = MutexFactory::instance()->createMutex();
   if (mutex == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "LocalDataPoolManager",
-                        HasReturnvaluesIF::RETURN_FAILED, "Could not create mutex");
+    printWarningOrError(sif::LogLevel::ERROR, "ctor", HasReturnvaluesIF::RETURN_FAILED,
+                        "Could not create mutex");
   }
 
   hkQueue = queueToUse;
@@ -44,25 +45,25 @@ LocalDataPoolManager::~LocalDataPoolManager() {
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   if (queueToUse == nullptr) {
     /* Error, all destinations invalid */
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
+    printWarningOrError(sif::LogLevel::ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
   }
   hkQueue = queueToUse;
 
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   if (ipcStore == nullptr) {
     /* Error, all destinations invalid */
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::LogLevel::ERROR, "initialize", HasReturnvaluesIF::RETURN_FAILED,
                         "Could not set IPC store.");
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   if (defaultHkDestination != objects::NO_OBJECT) {
-    AcceptsHkPacketsIF* hkPacketReceiver =
+    auto* hkPacketReceiver =
         ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
     if (hkPacketReceiver != nullptr) {
       hkDestinationId = hkPacketReceiver->getHkQueue();
     } else {
-      printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
+      printWarningOrError(sif::LogLevel::ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
       return QUEUE_OR_DESTINATION_INVALID;
     }
   }
@@ -84,7 +85,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
     return result;
   }
 
-  printWarningOrError(sif::OutputTypes::OUT_WARNING, "initializeHousekeepingPoolEntriesOnce",
+  printWarningOrError(sif::LogLevel::WARNING, "initializeHousekeepingPoolEntriesOnce",
                       HasReturnvaluesIF::RETURN_FAILED, "The map should only be initialized once");
   return HasReturnvaluesIF::RETURN_OK;
 }
@@ -150,8 +151,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
     LocalPoolObjectBase* poolObj =
         HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId);
     if (poolObj == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate",
-                          POOLOBJECT_NOT_FOUND);
+      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
       return POOLOBJECT_NOT_FOUND;
     }
     if (poolObj->hasChanged()) {
@@ -170,8 +170,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
     LocalPoolDataSetBase* dataSet =
         HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
     if (dataSet == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate",
-                          DATASET_NOT_FOUND);
+      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationUpdate", DATASET_NOT_FOUND);
       return DATASET_NOT_FOUND;
     }
     if (dataSet->hasChanged()) {
@@ -199,7 +198,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     LocalPoolObjectBase* poolObj =
         HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId);
     if (poolObj == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationSnapshot",
+      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationSnapshot",
                           POOLOBJECT_NOT_FOUND);
       return POOLOBJECT_NOT_FOUND;
     }
@@ -235,8 +234,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     LocalPoolDataSetBase* dataSet =
         HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
     if (dataSet == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationSnapshot",
-                          DATASET_NOT_FOUND);
+      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationSnapshot", DATASET_NOT_FOUND);
       return DATASET_NOT_FOUND;
     }
 
@@ -245,9 +243,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),
@@ -342,7 +340,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
   AcceptsHkPacketsIF* hkReceiverObject =
       ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
+    printWarningOrError(sif::LogLevel::WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
     return QUEUE_OR_DESTINATION_INVALID;
   }
@@ -368,10 +366,9 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid, bool isDiagnostics,
                                                              bool reportingEnabled,
                                                              object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
+  auto* hkReceiverObject = ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
+    printWarningOrError(sif::LogLevel::WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
     return QUEUE_OR_DESTINATION_INVALID;
   }
@@ -524,8 +521,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
     case (HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
       LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
       if (dataSet == nullptr) {
-        printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
-                            DATASET_NOT_FOUND);
+        printWarningOrError(sif::LogLevel::WARNING, "handleHousekeepingMessage", DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
       }
       if (command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT and
@@ -588,8 +584,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 ReturnValue_t LocalDataPoolManager::printPoolEntry(lp_id_t localPoolId) {
   auto poolIter = localPoolMap.find(localPoolId);
   if (poolIter == localPoolMap.end()) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
-                        localpool::POOL_ENTRY_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "printPoolEntry", localpool::POOL_ENTRY_NOT_FOUND);
     return localpool::POOL_ENTRY_NOT_FOUND;
   }
   poolIter->second->print();
@@ -606,8 +601,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
                                                                MessageQueueId_t destination) {
   if (dataSet == nullptr) {
     /* Configuration error. */
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
-                        DATASET_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "generateHousekeepingPacket", DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -630,14 +624,14 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
   if (hkQueue == nullptr) {
     /* Error, no queue available to send packet with. */
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
+    printWarningOrError(sif::LogLevel::WARNING, "generateHousekeepingPacket",
                         QUEUE_OR_DESTINATION_INVALID);
     return QUEUE_OR_DESTINATION_INVALID;
   }
   if (destination == MessageQueueIF::NO_QUEUE) {
     if (hkDestinationId == MessageQueueIF::NO_QUEUE) {
       /* Error, all destinations invalid */
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
+      printWarningOrError(sif::LogLevel::WARNING, "generateHousekeepingPacket",
                           QUEUE_OR_DESTINATION_INVALID);
     }
     destination = hkDestinationId;
@@ -671,8 +665,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   sid_t sid = receiver.dataId.sid;
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
-                        DATASET_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "performPeriodicHkGeneration", DATASET_NOT_FOUND);
     return;
   }
 
@@ -695,12 +688,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   ReturnValue_t result = generateHousekeepingPacket(sid, dataSet, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     /* Configuration error */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
-                 << std::endl;
-#else
-    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
-#endif
+    FSFW_LOGWT("performPeriodicHkOperation: HK generation failed\n");
   }
 }
 
@@ -708,8 +696,7 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, bool ena
                                                              bool isDiagnostics) {
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "togglePeriodicGeneration",
-                        DATASET_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "togglePeriodicGeneration", DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -731,8 +718,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float ne
                                                              bool isDiagnostics) {
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "changeCollectionInterval",
-                        DATASET_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "changeCollectionInterval", DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -757,8 +743,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   /* Get and check dataset first. */
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
-                        DATASET_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "performPeriodicHkGeneration", DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -779,7 +764,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   store_address_t storeId;
   ReturnValue_t result = ipcStore->getFreeElement(&storeId, expectedSize, &storePtr);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "generateSetStructurePacket",
+    printWarningOrError(sif::LogLevel::ERROR, "generateSetStructurePacket",
                         HasReturnvaluesIF::RETURN_FAILED,
                         "Could not get free element from IPC store.");
     return result;
@@ -793,7 +778,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
     return result;
   }
   if (expectedSize != size) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
+    printWarningOrError(sif::LogLevel::WARNING, "generateSetStructurePacket",
                         HasReturnvaluesIF::RETURN_FAILED,
                         "Expected size is not equal to serialized size");
   }
@@ -826,9 +811,8 @@ MutexIF* LocalDataPoolManager::getLocalPoolMutex() { return this->mutex; }
 
 object_id_t LocalDataPoolManager::getCreatorObjectId() const { return owner->getObjectId(); }
 
-void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
-                                               const char* functionName, ReturnValue_t error,
-                                               const char* errorPrint) {
+void LocalDataPoolManager::printWarningOrError(sif::LogLevel outputType, const char* functionName,
+                                               ReturnValue_t error, const char* errorPrint) {
 #if FSFW_VERBOSE_LEVEL >= 1
   if (errorPrint == nullptr) {
     if (error == DATASET_NOT_FOUND) {
@@ -836,7 +820,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
     } else if (error == POOLOBJECT_NOT_FOUND) {
       errorPrint = "Pool Object not found";
     } else if (error == HasReturnvaluesIF::RETURN_FAILED) {
-      if (outputType == sif::OutputTypes::OUT_WARNING) {
+      if (outputType == sif::LogLevel::WARNING) {
         errorPrint = "Generic Warning";
       } else {
         errorPrint = "Generic error";
@@ -856,24 +840,10 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
     objectId = owner->getObjectId();
   }
 
-  if (outputType == sif::OutputTypes::OUT_WARNING) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
-                 << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
-                 << std::setfill(' ') << std::endl;
-#else
-    sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
-                      errorPrint);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-  } else if (outputType == sif::OutputTypes::OUT_ERROR) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
-               << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
-               << std::setfill(' ') << std::endl;
-#else
-    sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
-                    errorPrint);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+  if (outputType == sif::LogLevel::WARNING) {
+    FSFW_LOGWT("{} | Object ID {} | {}\n", functionName, objectId, errorPrint);
+  } else if (outputType == sif::LogLevel::ERROR) {
+    FSFW_LOGET("{} | Object ID {} | {}\n", functionName, objectId, errorPrint);
   }
 #endif /* #if FSFW_VERBOSE_LEVEL >= 1 */
 }

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -16,7 +16,7 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/ipc/MutexIF.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -375,7 +375,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver, ReturnValue_t& status);
   ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
 
-  void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
+  void printWarningOrError(sif::LogLevel outputType, const char* functionName,
                            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
                            const char* errorPrint = nullptr);
 };
@@ -389,14 +389,13 @@ inline ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 
   auto poolIter = localPoolMap.find(localPoolId);
   if (poolIter == localPoolMap.end()) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
-                        localpool::POOL_ENTRY_NOT_FOUND);
+    printWarningOrError(sif::LogLevel::WARNING, "fetchPoolEntry", localpool::POOL_ENTRY_NOT_FOUND);
     return localpool::POOL_ENTRY_NOT_FOUND;
   }
 
   *poolEntry = dynamic_cast<PoolEntry<T>*>(poolIter->second);
   if (*poolEntry == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
+    printWarningOrError(sif::LogLevel::WARNING, "fetchPoolEntry",
                         localpool::POOL_ENTRY_TYPE_CONFLICT);
     return localpool::POOL_ENTRY_TYPE_CONFLICT;
   }

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -7,7 +7,7 @@
 #include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serialize/SerializeAdapter.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t setId,
@@ -16,14 +16,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t
     : PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
   if (hkOwner == nullptr) {
     // Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-               << "invalid!" << std::endl;
-#else
-    sif::printError(
-        "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-        "invalid!\n\r");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+    FSFW_LOGW("{}", "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner invalid\n");
     return;
   }
   AccessPoolManagerIF *accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
@@ -186,14 +179,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t **buffer, size
     auto result =
         SerializeAdapter::serialize(&currentPoolId, buffer, size, maxSize, streamEndianness);
     if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
-                   << "Serialization error!" << std::endl;
-#else
-      sif::printWarning(
-          "LocalPoolDataSetBase::serializeLocalPoolIds: "
-          "Serialization error!\n\r");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      FSFW_LOGW("{}", "serializeLocalPoolIds: Serialization error\n");
       return result;
     }
   }

src/fsfw/datapoollocal/LocalPoolObjectBase.cpp

@@ -4,22 +4,17 @@
 #include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
                                          DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
     : localPoolId(poolId), readWriteMode(setReadWriteMode) {
   if (poolId == PoolVariableIF::NO_PARAMETER) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                 << "which is the NO_PARAMETER value!" << std::endl;
-#endif
+    FSFW_LOGWT("{}", "ctor: Invalid pool ID, has NO_PARAMETER value\n");
   }
   if (hkOwner == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-               << "owner is a invalid!" << std::endl;
-#endif
+    FSFW_LOGET("{}", "ctor: Supplied pool owner is a invalid\n");
     return;
   }
   AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
@@ -34,28 +29,14 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
                                          pool_rwm_t setReadWriteMode)
     : localPoolId(poolId), readWriteMode(setReadWriteMode) {
   if (poolId == PoolVariableIF::NO_PARAMETER) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalPoolVar<T>::L