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;

scripts/auto-formatter.sh

@@ -4,9 +4,10 @@ if [[ ! -f README.md ]]; then
 fi
 
 cmake_fmt="cmake-format"
+file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
-  cmake_fmt_cmd="${cmake_fmt} -i CMakeLists.txt"
+  ${cmake_fmt} -i CMakeLists.txt
-  eval ${cmake_fmt_cmd}
+  find ./src ${file_selectors} | xargs ${cmake_fmt}  -i
 else
   echo "No ${cmake_fmt} tool found, not formatting CMake files"
 fi
@@ -14,9 +15,9 @@ 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 clang-format --style=file -i
+  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./hal ${file_selectors} | xargs clang-format --style=file -i
+  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./tests ${file_selectors} | xargs clang-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/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/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/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/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/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/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

@@ -1062,7 +1062,8 @@ 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;
+  virtual 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/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/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/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/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/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/objectmanager/CMakeLists.txt

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

src/fsfw/objectmanager/SystemObject.h

@@ -50,7 +50,8 @@ class SystemObject : public SystemObjectIF {
   virtual ReturnValue_t initialize() override;
   virtual ReturnValue_t checkObjectConnections() override;
 
-  virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const override;
+  virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+                            uint32_t parameter2 = 0) const override;
 };
 
 #endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */

src/fsfw/osal/CMakeLists.txt

@@ -1,35 +1,33 @@
 # Check the OS_FSFW variable
 if(FSFW_OSAL MATCHES "freertos")
-    add_subdirectory(freertos)
+  add_subdirectory(freertos)
 elseif(FSFW_OSAL MATCHES "rtems")
-    add_subdirectory(rtems)
+  add_subdirectory(rtems)
 elseif(FSFW_OSAL MATCHES "linux")
-    add_subdirectory(linux)
+  add_subdirectory(linux)
 elseif(FSFW_OSAL MATCHES "host")
-    add_subdirectory(host)
+  add_subdirectory(host)
-    if (WIN32)
+  if(WIN32)
-        add_subdirectory(windows)
+    add_subdirectory(windows)
-    elseif(UNIX)
+  elseif(UNIX)
-        # We still need to pull in some Linux specific sources
+    # We still need to pull in some Linux specific sources
-        target_sources(${LIB_FSFW_NAME} PUBLIC
+    target_sources(${LIB_FSFW_NAME} PUBLIC linux/tcpipHelpers.cpp)
-            linux/tcpipHelpers.cpp
+  endif()
-        )
-    endif ()
 
 else()
 
-    message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
+  message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
-    # Not set. Assumuing this is a host build, try to determine host OS
+  # Not set. Assumuing this is a host build, try to determine host OS
-    if (WIN32)
+  if(WIN32)
-        add_subdirectory(host)
+    add_subdirectory(host)
-        add_subdirectory(windows)
+    add_subdirectory(windows)
-    elseif (UNIX)
+  elseif(UNIX)
-        add_subdirectory(linux)
+    add_subdirectory(linux)
-    else ()
+  else()
-        # MacOS or other OSes have not been tested yet / are not supported.
+    # MacOS or other OSes have not been tested yet / are not supported.
-        message(FATAL_ERROR "The host OS could not be determined! Aborting.")
+    message(FATAL_ERROR "The host OS could not be determined! Aborting.")
-    endif()
+  endif()
 
 endif()
 
-add_subdirectory(common)
+add_subdirectory(common)

src/fsfw/osal/common/CMakeLists.txt

@@ -1,17 +1,10 @@
 if(DEFINED WIN32 OR DEFINED UNIX)
-    target_sources(${LIB_FSFW_NAME} PRIVATE 
+  target_sources(
-        tcpipCommon.cpp
+    ${LIB_FSFW_NAME}
-        TcpIpBase.cpp
+    PRIVATE tcpipCommon.cpp TcpIpBase.cpp UdpTcPollingTask.cpp
-        UdpTcPollingTask.cpp
+            UdpTmTcBridge.cpp TcpTmTcServer.cpp TcpTmTcBridge.cpp)
-        UdpTmTcBridge.cpp
-        TcpTmTcServer.cpp
-        TcpTmTcBridge.cpp
-    )
 endif()
 
 if(WIN32)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE wsock32 ws2_32)
-        wsock32 
+endif()
-        ws2_32
-    )
-endif()

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -161,7 +161,7 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
 
   while (true) {
     ssize_t retval = recv(connSocket, reinterpret_cast<char*>(receptionBuffer.data()),
-                      receptionBuffer.capacity(), tcpConfig.tcpFlags);
+                          receptionBuffer.capacity(), tcpConfig.tcpFlags);
     if (retval == 0) {
       size_t availableReadData = ringBuffer.getAvailableReadData();
       if (availableReadData > lastRingBufferSize) {
@@ -285,7 +285,7 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
       arrayprinter::print(storeAccessor.data(), storeAccessor.size());
     }
     ssize_t retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
-                      storeAccessor.size(), tcpConfig.tcpTmFlags);
+                          storeAccessor.size(), tcpConfig.tcpTmFlags);
     if (retval == static_cast<int>(storeAccessor.size())) {
       // Packet sent, clear FIFO entry
       tmtcBridge->tmFifo->pop();
@@ -340,7 +340,7 @@ ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
   size_t foundSize = 0;
   size_t readLen = 0;
   while (readLen < readAmount) {
-    if(spacePacketParser == nullptr) {
+    if (spacePacketParser == nullptr) {
       return HasReturnvaluesIF::RETURN_FAILED;
     }
     result =

src/fsfw/osal/common/UdpTcPollingTask.cpp

@@ -154,7 +154,7 @@ void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
 #endif
   }
 #elif defined(PLATFORM_UNIX)
-  timeval tval {};
+  timeval tval{};
   tval = timevalOperations::toTimeval(timeoutSeconds);
   int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof(receptionTimeout));
   if (result == -1) {

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -20,7 +20,7 @@
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             const std::string& udpServerPort_, object_id_t tmStoreId,
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
                              object_id_t tcStoreId)
     : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
   if (udpServerPort_.empty()) {
@@ -118,7 +118,7 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
 #endif
 
   ssize_t bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
-                         &clientAddress, clientAddressLen);
+                             &clientAddress, clientAddressLen);
   if (bytesSent == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "TmTcUdpBridge::sendTm: Send operation failed." << std::endl;

src/fsfw/osal/common/UdpTmTcBridge.h

@@ -29,8 +29,8 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
   /* The ports chosen here should not be used by any other process. */
   static const std::string DEFAULT_SERVER_PORT;
 
-  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination, const std::string& udpServerPort = "",
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                object_id_t tmStoreId = objects::TM_STORE,
+                const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   ~UdpTmTcBridge() override;
 

src/fsfw/osal/freertos/CMakeLists.txt

@@ -1,32 +1,30 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		Clock.cpp
+  PRIVATE Clock.cpp
-		FixedTimeslotTask.cpp
+          FixedTimeslotTask.cpp
-		BinarySemaphore.cpp
+          BinarySemaphore.cpp
-		BinSemaphUsingTask.cpp
+          BinSemaphUsingTask.cpp
-		CountingSemaphore.cpp
+          CountingSemaphore.cpp
-		CountingSemaphUsingTask.cpp
+          CountingSemaphUsingTask.cpp
-		MessageQueue.cpp
+          MessageQueue.cpp
-		Mutex.cpp
+          Mutex.cpp
-		MutexFactory.cpp
+          MutexFactory.cpp
-		PeriodicTask.cpp
+          PeriodicTask.cpp
-		QueueFactory.cpp
+          QueueFactory.cpp
-		SemaphoreFactory.cpp
+          SemaphoreFactory.cpp
-		TaskFactory.cpp
+          TaskFactory.cpp
-		Timekeeper.cpp
+          Timekeeper.cpp
-		TaskManagement.cpp
+          TaskManagement.cpp
-		QueueMapManager.cpp
+          QueueMapManager.cpp)
-)
 
-# FreeRTOS is required to link the FSFW now. It is recommended to compile 
+# FreeRTOS is required to link the FSFW now. It is recommended to compile
-# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the 
+# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the
 # library.
 if(NOT LIB_OS_NAME)
-	message(STATUS
+  message(
-		"LIB_OS_NAME is empty. Make sure to include the FreeRTOS header path properly."
+    STATUS
-	)
+      "LIB_OS_NAME is empty. Make sure to include the FreeRTOS header path properly."
+  )
 else()
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
-        ${LIB_OS_NAME}
-    )
 endif()

src/fsfw/osal/host/CMakeLists.txt

@@ -1,27 +1,23 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-  Clock.cpp
+  ${LIB_FSFW_NAME}
-  FixedTimeslotTask.cpp
+  PRIVATE Clock.cpp
-  MessageQueue.cpp
+          FixedTimeslotTask.cpp
-  Mutex.cpp
+          MessageQueue.cpp
-  MutexFactory.cpp
+          Mutex.cpp
-  PeriodicTask.cpp
+          MutexFactory.cpp
-  QueueFactory.cpp
+          PeriodicTask.cpp
-  QueueMapManager.cpp
+          QueueFactory.cpp
-  SemaphoreFactory.cpp
+          QueueMapManager.cpp
-  TaskFactory.cpp
+          SemaphoreFactory.cpp
-  taskHelpers.cpp
+          TaskFactory.cpp
-)
+          taskHelpers.cpp)
 
 if(UNIX)
   find_package(Threads REQUIRED)
 
-  target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
-    ${CMAKE_THREAD_LIBS_INIT}
-  )
   if(NOT APPLE)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE rt)
-      rt
-      )
   endif()
 
-endif()
+endif()

src/fsfw/osal/linux/CMakeLists.txt

@@ -1,29 +1,25 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-  Clock.cpp
+  ${LIB_FSFW_NAME}
-  BinarySemaphore.cpp
+  PRIVATE Clock.cpp
-  CountingSemaphore.cpp
+          BinarySemaphore.cpp
-  FixedTimeslotTask.cpp
+          CountingSemaphore.cpp
-  InternalErrorCodes.cpp
+          FixedTimeslotTask.cpp
-  MessageQueue.cpp
+          InternalErrorCodes.cpp
-  Mutex.cpp
+          MessageQueue.cpp
-  MutexFactory.cpp
+          Mutex.cpp
-  PeriodicPosixTask.cpp
+          MutexFactory.cpp
-  PosixThread.cpp
+          PeriodicPosixTask.cpp
-  QueueFactory.cpp
+          PosixThread.cpp
-  SemaphoreFactory.cpp
+          QueueFactory.cpp
-  TaskFactory.cpp
+          SemaphoreFactory.cpp
-  tcpipHelpers.cpp
+          TaskFactory.cpp
-  unixUtility.cpp
+          tcpipHelpers.cpp
-  )
+          unixUtility.cpp)
 
 find_package(Threads REQUIRED)
 
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC
+target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${CMAKE_THREAD_LIBS_INIT})
-  ${CMAKE_THREAD_LIBS_INIT}
-  )
 
 if(NOT APPLE)
-  target_link_libraries(${LIB_FSFW_NAME} PUBLIC
+  target_link_libraries(${LIB_FSFW_NAME} PUBLIC rt)
-    rt
-  )
 endif()

src/fsfw/osal/rtems/CMakeLists.txt

@@ -1,20 +1,17 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		Clock.cpp
+  PRIVATE Clock.cpp
-		CpuUsage.cpp
+          CpuUsage.cpp
-		InitTask.cpp
+          InitTask.cpp
-		InternalErrorCodes.cpp
+          InternalErrorCodes.cpp
-		MessageQueue.cpp
+          MessageQueue.cpp
-		PeriodicTask.cpp
+          PeriodicTask.cpp
-		Mutex.cpp
+          Mutex.cpp
-		MutexFactory.cpp
+          MutexFactory.cpp
-		FixedTimeslotTask.cpp
+          FixedTimeslotTask.cpp
-		QueueFactory.cpp
+          QueueFactory.cpp
-		RtemsBasic.cpp
+          RtemsBasic.cpp
-		RTEMSTaskBase.cpp
+          RTEMSTaskBase.cpp
-		TaskFactory.cpp
+          TaskFactory.cpp
-		BinarySemaphore.cpp
+          BinarySemaphore.cpp
-		SemaphoreFactory.cpp
+          SemaphoreFactory.cpp)
-)
-
-

src/fsfw/osal/windows/CMakeLists.txt

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

src/fsfw/parameters/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE ParameterHelper.cpp ParameterMessage.cpp
-		ParameterHelper.cpp
+                           ParameterWrapper.cpp)
-		ParameterMessage.cpp
-		ParameterWrapper.cpp
-)

src/fsfw/power/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    Fuse.cpp
+  ${LIB_FSFW_NAME} PRIVATE Fuse.cpp PowerComponent.cpp PowerSensor.cpp
-    PowerComponent.cpp
+                           PowerSwitcher.cpp DummyPowerSwitcher.cpp)
-    PowerSensor.cpp
-    PowerSwitcher.cpp
-    DummyPowerSwitcher.cpp
-)

src/fsfw/pus/CMakeLists.txt

@@ -1,12 +1,12 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(
-    Service1TelecommandVerification.cpp
+  ${LIB_FSFW_NAME}
-    Service2DeviceAccess.cpp
+  PRIVATE Service1TelecommandVerification.cpp
-    Service3Housekeeping.cpp
+          Service2DeviceAccess.cpp
-    Service5EventReporting.cpp
+          Service3Housekeeping.cpp
-    Service8FunctionManagement.cpp
+          Service5EventReporting.cpp
-    Service9TimeManagement.cpp
+          Service8FunctionManagement.cpp
-    Service17Test.cpp
+          Service9TimeManagement.cpp
-    Service20ParameterManagement.cpp
+          Service17Test.cpp
-    CService200ModeCommanding.cpp
+          Service20ParameterManagement.cpp
-    CService201HealthCommanding.cpp
+          CService200ModeCommanding.cpp
-)
+          CService201HealthCommanding.cpp)

src/fsfw/pus/CService201HealthCommanding.cpp

@@ -97,7 +97,8 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
 }
 
 // Not used for now, health state already reported by event
-[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(const CommandMessage *reply) {
+[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
+    const CommandMessage *reply) {
   auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
   auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
   HealthSetReply healthSetReply(health, oldHealth);

src/fsfw/pus/CService201HealthCommanding.h

@@ -39,7 +39,7 @@ class CService201HealthCommanding : public CommandingServiceBase {
 
  private:
   static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
-                                                     const object_id_t *objectId);
+                                                            const object_id_t *objectId);
 
   [[maybe_unused]] ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
 

src/fsfw/rmap/CMakeLists.txt

@@ -1,7 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE RMAP.cpp RMAPCookie.cpp
-	PRIVATE 
+                                        RmapDeviceCommunicationIF.cpp)
-		RMAP.cpp
-		RMAPCookie.cpp
-		RmapDeviceCommunicationIF.cpp
-)
-

src/fsfw/serialize/CMakeLists.txt

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

src/fsfw/serviceinterface/CMakeLists.txt

@@ -1,5 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(
-	ServiceInterfaceStream.cpp
+  ${LIB_FSFW_NAME}
-	ServiceInterfaceBuffer.cpp
+  PRIVATE ServiceInterfaceStream.cpp ServiceInterfaceBuffer.cpp
-	ServiceInterfacePrinter.cpp
+          ServiceInterfacePrinter.cpp)
-)

src/fsfw/storagemanager/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE ConstStorageAccessor.cpp StorageAccessor.cpp
-		ConstStorageAccessor.cpp
+                           LocalPool.cpp PoolManager.cpp)
-		StorageAccessor.cpp
-		LocalPool.cpp
-		PoolManager.cpp
-)

src/fsfw/subsystem/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE Subsystem.cpp SubsystemBase.cpp)
-	PRIVATE 
-		Subsystem.cpp
-		SubsystemBase.cpp
-)
 
-add_subdirectory(modes)
+add_subdirectory(modes)

src/fsfw/subsystem/modes/CMakeLists.txt

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

src/fsfw/tasks/CMakeLists.txt

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

src/fsfw/tcdistribution/CMakeLists.txt

@@ -1,9 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(
-    CCSDSDistributor.cpp
+  ${LIB_FSFW_NAME}
-    PUSDistributor.cpp
+  PRIVATE CCSDSDistributor.cpp PUSDistributor.cpp TcDistributor.cpp
-    TcDistributor.cpp
+          TcPacketCheckPUS.cpp TcPacketCheckCFDP.cpp CFDPDistributor.cpp)
-    TcPacketCheckPUS.cpp
-    TcPacketCheckCFDP.cpp
-    CFDPDistributor.cpp
-)
-

src/fsfw/thermal/CMakeLists.txt

@@ -1,10 +1,9 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		AbstractTemperatureSensor.cpp
+  PRIVATE AbstractTemperatureSensor.cpp
-		Heater.cpp
+          Heater.cpp
-		RedundantHeater.cpp
+          RedundantHeater.cpp
-		ThermalComponentCore.cpp
+          ThermalComponentCore.cpp
-		ThermalComponent.cpp
+          ThermalComponent.cpp
-		ThermalModule.cpp
+          ThermalModule.cpp
-		ThermalMonitorReporter.cpp
+          ThermalMonitorReporter.cpp)
-)

src/fsfw/timemanager/CMakeLists.txt

@@ -1,8 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    CCSDSTime.cpp
+  ${LIB_FSFW_NAME} PRIVATE CCSDSTime.cpp Countdown.cpp Stopwatch.cpp
-    Countdown.cpp
+                           TimeMessage.cpp TimeStamper.cpp ClockCommon.cpp)
-    Stopwatch.cpp
-    TimeMessage.cpp
-    TimeStamper.cpp
-    ClockCommon.cpp
-)

src/fsfw/tmstorage/CMakeLists.txt

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

src/fsfw/tmtcpacket/CMakeLists.txt

@@ -1,8 +1,5 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(${LIB_FSFW_NAME} PRIVATE SpacePacket.cpp SpacePacketBase.cpp)
-    SpacePacket.cpp
-    SpacePacketBase.cpp
-)
 
 add_subdirectory(cfdp)
 add_subdirectory(packetmatcher)
-add_subdirectory(pus)
+add_subdirectory(pus)

src/fsfw/tmtcpacket/cfdp/CMakeLists.txt

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

src/fsfw/tmtcpacket/packetmatcher/CMakeLists.txt

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

src/fsfw/tmtcpacket/pus/tc/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE    
+target_sources(
-    TcPacketPusBase.cpp
+  ${LIB_FSFW_NAME} PRIVATE TcPacketPusBase.cpp TcPacketPus.cpp
-    TcPacketPus.cpp
+                           TcPacketStoredBase.cpp TcPacketStoredPus.cpp)
-    TcPacketStoredBase.cpp
-    TcPacketStoredPus.cpp
-)

src/fsfw/tmtcpacket/pus/tm/CMakeLists.txt

@@ -1,9 +1,9 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    TmPacketStoredPusA.cpp
+  ${LIB_FSFW_NAME}
-    TmPacketStoredPusC.cpp
+  PRIVATE TmPacketStoredPusA.cpp
-    TmPacketPusA.cpp
+          TmPacketStoredPusC.cpp
-    TmPacketPusC.cpp
+          TmPacketPusA.cpp
-    TmPacketStoredBase.cpp
+          TmPacketPusC.cpp
-    TmPacketBase.cpp
+          TmPacketStoredBase.cpp
-    TmPacketMinimal.cpp
+          TmPacketBase.cpp
-)
+          TmPacketMinimal.cpp)

src/fsfw/tmtcservices/CMakeLists.txt

@@ -1,10 +1,9 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		CommandingServiceBase.cpp
+  PRIVATE CommandingServiceBase.cpp
-		PusServiceBase.cpp
+          PusServiceBase.cpp
-		PusVerificationReport.cpp
+          PusVerificationReport.cpp
-		TmTcBridge.cpp
+          TmTcBridge.cpp
-		TmTcMessage.cpp
+          TmTcMessage.cpp
-		VerificationReporter.cpp
+          VerificationReporter.cpp
-		SpacePacketParser.cpp
+          SpacePacketParser.cpp)
-)

tests/src/fsfw_tests/unit/power/testPowerSwitcher.cpp

@@ -67,7 +67,5 @@ TEST_CASE("Power Switcher", "[power-switcher]") {
     REQUIRE(not switcherUsingDummy.active());
   }
 
-  SECTION("More Dummy Tests") {
+  SECTION("More Dummy Tests") {}
-
-  }
 }