Merge pull request 'Apollo Sojus Test Project Version 1.0.0' (#408) from development into master

Reviewed-on: fsfw/fsfw#408

CHANGELOG

@@ -0,0 +1,98 @@
+## Changes from ASTP 0.0.1 to 1.0.0
+
+### Host OSAL
+
+- Bugfix in MessageQueue, which caused the sender not to be set properly
+
+### FreeRTOS OSAL
+
+- vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
+a C file without issues
+
+### PUS Services
+
+- It is now possible to change the message queue depth for the telecommand verification service (PUS1)
+- The same is possible for the event reporting service (PUS5)
+- PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+
+### EnhancedControllerBase
+
+- New base class for a controller which also implements HasActionsIF and HasLocalDataPoolIF
+
+### Local Pool
+
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and
+bucket number of the pools per page and the number of pages are passed to the ctor instead of
+two ctor arguments and a template parameter
+
+### Parameter Service
+
+- The API of the parameter service has been changed to prevent inconsistencies
+between documentation and actual code and to clarify usage.
+- The parameter ID now consists of:
+	1. Domain ID (1 byte)
+	2. Unique Identifier (1 byte)
+	3. Linear Index (2 bytes)
+The linear index can be used for arrays as well as matrices.
+The parameter load command now explicitely expects the ECSS PTC and PFC
+information as well as  the rows and column number. Rows and column will
+default to one, which is equivalent to one scalar parameter (the most
+important use-case)
+   
+### File System Interface
+
+- A new interfaces specifies the functions for a software object which exposes the file system of
+a given hardware to use message based file handling (e.g. PUS commanding)
+
+### Internal Error Reporter
+
+- The new internal error reporter uses the local data pools. The pool IDs for
+the exisiting three error values and the new error set will be hardcoded for
+now, the the constructor for the internal error reporter just takes an object
+ID for now.
+
+### Device Handler Base
+
+- There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
+that DHB users adapt their polling sequence tables to perform this step. This steps allows for 
+a clear distinction between operation and communication steps
+- setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
+- getTransitionDelayMs is now an abstract method
+
+### DeviceHandlerIF
+
+- Typo for UNKNOWN_DEVICE_REPLY 
+
+### Events
+
+- makeEvent function: Now takes three input parameters instead of two and
+allows setting a unique ID. Event.cpp source file removed, functions now
+defined in header directly. Namespaces renamed. Functions declared `constexpr`
+now
+
+### Commanding Service Base
+
+- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each 
+CSB instance. This variable has to be set in the FSFWConfig.h file
+
+### Service Interface
+
+- Proper printf support contained in ServiceInterfacePrinter.h
+- CPP ostream support now optional (can reduce executable size by 150 - 250 kB)
+- Amalagated header which determines automatically which service interface to use depending on FSFWConfig.h configuration. 
+  Users can just use #include <fsfw/serviceinterface/ServiceInterface.h>
+- If CPP streams are excluded, sif:: calls won't work anymore and need to be replaced by their printf counterparts. 
+  For the fsfw, this can be done by checking the processor define FSFW_CPP_OSTREAM_ENABLED from FSFWConfig.h. 
+  For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
+  If this is not the case, everything should work as usual.
+
+### ActionHelper and ActionMessage
+
+- ActionHelper finish function and ActionMessage::setCompletionReply now expects explicit 
+information whether to report a success or failure message instead of deriving it implicitely 
+from returnvalue
+
+### PUS Parameter Service 20
+
+Added PUS parameter service 20 (only custom subservices available).

CMakeLists.txt

@@ -0,0 +1,206 @@
+cmake_minimum_required(VERSION 3.13)
+
+option(FSFW_GENERATE_SECTIONS
+    "Generate function and data sections. Required to remove unused code" ON
+)
+
+if(FSFW_GENERATE_SECTIONS)
+    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+endif()
+
+option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+# Options to exclude parts of the FSFW from compilation.
+option(FSFW_USE_RMAP "Compile with RMAP" ON)
+option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+
+set(LIB_FSFW_NAME fsfw)
+add_library(${LIB_FSFW_NAME})
+
+set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
+
+if(NOT OS_FSFW)
+	message(STATUS "No OS for FSFW via OS_FSFW set. Assuming host OS")
+	# Assume host OS and autodetermine from OS_FSFW
+	if(UNIX)
+		set(OS_FSFW  "linux" 
+			CACHE STRING 
+			"OS abstraction layer used in the FSFW"
+		)
+	elseif(WIN32)
+		set(OS_FSFW  "host" 
+			CACHE STRING "OS abstraction layer used in the FSFW"
+		)
+	endif()
+
+endif()
+
+set(FSFW_OSAL_DEFINITION FSFW_HOST)
+
+if(${OS_FSFW} STREQUAL host)
+	set(OS_FSFW_NAME "Host")
+elseif(${OS_FSFW} STREQUAL linux)
+	set(OS_FSFW_NAME "Linux")
+	set(FSFW_OSAL_DEFINITION FSFW_LINUX)
+elseif(${OS_FSFW} STREQUAL  freertos)
+	set(OS_FSFW_NAME "FreeRTOS")
+	set(FSFW_OSAL_DEFINITION FSFW_FREERTOS)
+	target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_OS_NAME}
+	)
+elseif(${OS_FSFW} STREQUAL rtems)
+	set(OS_FSFW_NAME "RTEMS")
+    set(FSFW_OSAL_DEFINITION FSFW_RTEMS)
+else()
+	message(WARNING 
+		"Invalid operating system for FSFW specified! Setting to host.."
+	)
+	set(OS_FSFW_NAME "Host")
+	set(OS_FSFW "host")
+endif()
+
+target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_OSAL_DEFINITION}
+)
+
+target_compile_definitions(${LIB_FSFW_NAME} INTERFACE
+    ${FSFW_OSAL_DEFINITION}
+)
+
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
+
+add_subdirectory(action)
+add_subdirectory(container)
+add_subdirectory(controller)
+add_subdirectory(coordinates)
+
+if(FSFW_USE_DATALINKLAYER)
+	add_subdirectory(datalinklayer)
+endif()
+
+add_subdirectory(datapool)
+add_subdirectory(datapoollocal)
+add_subdirectory(housekeeping)
+add_subdirectory(devicehandlers)
+add_subdirectory(events)
+add_subdirectory(fdir)
+add_subdirectory(globalfunctions)
+add_subdirectory(health)
+add_subdirectory(internalError)
+add_subdirectory(ipc)
+add_subdirectory(memory)
+add_subdirectory(modes)
+add_subdirectory(monitoring)
+add_subdirectory(objectmanager)
+add_subdirectory(osal)
+add_subdirectory(parameters)
+add_subdirectory(power)
+add_subdirectory(pus)
+
+if(FSFW_USE_RMAP)
+	add_subdirectory(rmap)
+endif()
+
+add_subdirectory(serialize)
+add_subdirectory(serviceinterface)
+add_subdirectory(storagemanager)
+add_subdirectory(subsystem)
+add_subdirectory(tasks)
+add_subdirectory(tcdistribution)
+add_subdirectory(thermal)
+add_subdirectory(timemanager)
+add_subdirectory(tmstorage)
+add_subdirectory(tmtcpacket)
+add_subdirectory(tmtcservices)
+add_subdirectory(unittest)
+
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
+# If this is not given, we include the default configuration and emit a warning.
+if(NOT FSFW_CONFIG_PATH)
+	message(WARNING "Flight Software Framework configuration path not set!")
+	message(WARNING "Setting default configuration!")
+	add_subdirectory(defaultcfg/fsfwconfig)
+endif()
+
+# FSFW might be part of a possibly complicated folder structure, so we 
+# extract the absolute path of the fsfwconfig folder.
+if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
+	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
+else()
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
+		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+	)
+endif()
+
+foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATH})
+    if(IS_ABSOLUTE ${INCLUDE_PATH})
+        set(CURR_ABS_INC_PATH "${FREERTOS_PATH}")
+    else()
+        get_filename_component(CURR_ABS_INC_PATH
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+    endif()
+
+    if(CMAKE_VERBOSE)
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    endif()
+
+    list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+endforeach()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(NOT DEFINED FSFW_WARNING_FLAGS)
+	   set(FSFW_WARNING_FLAGS
+		  -Wall
+		  -Wextra
+		  -Wimplicit-fallthrough=1
+		  -Wno-unused-parameter
+		  -Wno-psabi
+        )
+    endif()
+
+    if(FSFW_GENERATE_SECTIONS)
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+            "-ffunction-sections"
+            "-fdata-sections"
+        )
+    endif()
+
+    if(FSFW_REMOVE_UNUSED_CODE)
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
+    endif()
+  
+    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+        list(APPEND WARNING_FLAGS "-Wshadow=local")
+    endif()
+	
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+	set(COMPILER_FLAGS "/permissive-")
+endif()
+
+# Required include paths to compile the FSFW
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
+
+# Includes path required to compile FSFW itself as well
+# We assume that the fsfwconfig folder uses include relative to the project
+# root here!
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_ADD_INC_PATHS_ABS}
+)
+
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${FSFW_WARNING_FLAGS}
+	${COMPILER_FLAGS}
+)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)

FSFWVersion.h

@@ -0,0 +1,12 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+const char* const FSFW_VERSION_NAME = "ASTP";
+
+#define FSFW_VERSION        1
+#define	FSFW_SUBVERSION     0
+#define	FSFW_REVISION       0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */

NOTICE

@@ -4,6 +4,8 @@ The initial version of the Flight Software Framework was developed during
 the Flying Laptop Project by the Universität Stuttgart in coorporation
 with Airbus Defence and Space GmbH.
 
+The supreme FSFW Logo was designed by Markus Koller and Luise Trilsbach.
+
 Copyrights in the Flight Software Framework are retained by their contributors.
 No copyright assignment is required to contribute to the Flight Software Framework.
 

README.md

@@ -0,0 +1,48 @@
+![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+
+# Flight Software Framework (FSFW)
+
+The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
+automated systems like Satellites. 
+
+The initial version of the Flight Software Framework was developed during
+the Flying Laptop Project by the University of Stuttgart in cooperation
+with Airbus Defence and Space GmbH.
+
+## Quick facts
+
+The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore, a mode and health system provides control over the states of the software and the controlled devices. In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
+
+The FSFW provides abstraction layers for operating systems to provide a uniform operating system abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is also very useful for developers to implement the same application logic on different operating systems with a uniform interface.
+
+Currently, the FSFW provides the following OSALs:
+
+- Linux
+- Host 
+- FreeRTOS
+- RTEMS
+
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active satellite mission Flying Laptop.
+
+## Getting started
+
+The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo to see the FSFW capabilities and build it with the Make or the CMake build system. It is recommended to evaluate the FSFW by building and playing around with the demo application.
+
+Generally, the FSFW is included in a project by compiling the FSFW sources and providing
+a configuration folder and adding it to the include path. There are some functions like `printChar` which are different depending on the target architecture and need to be implemented by the mission developer.
+
+A template configuration folder was provided and can be copied into the project root to have
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about the possible options.
+
+## Index
+
+[1. High-level overview](doc/README-highlevel.md#top) <br>
+[2. Core components](doc/README-core.md#top) <br>
+[3. OSAL overview](doc/README-osal.md#top) <br>
+[4. PUS services](doc/README-pus.md#top) <br>
+[5. Device Handler overview](doc/README-devicehandlers.md#top) <br>
+[6. Controller overview](doc/README-controllers.md#top) <br>
+[7. Local Data Pools](doc/README-localpools.md#top) <br>
+
+
+

action/ActionHelper.cpp

@@ -1,110 +1,167 @@
-#include <framework/action/ActionHelper.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
+#include "ActionHelper.h"
+#include "HasActionsIF.h"
 
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serviceinterface/ServiceInterface.h"
+
+ActionHelper::ActionHelper(HasActionsIF* setOwner,
+        MessageQueueIF* useThisQueue) :
+        owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
 }
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
+    if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+        ActionId_t currentAction = ActionMessage::getActionId(command);
+        prepareExecution(command->getSender(), currentAction,
+                ActionMessage::getStoreId(command));
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return CommandMessage::UNKNOWN_COMMAND;
+    }
 }
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if(queueToUse_ != nullptr) {
+        setQueueToUse(queueToUse_);
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
+        ActionId_t commandId, ReturnValue_t result) {
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
+void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
+        ReturnValue_t result) {
+    CommandMessage reply;
+    ActionMessage::setCompletionReply(&reply, commandId, success, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
+    queueToUse = queue;
 }
 
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+        ActionId_t actionId, store_address_t dataAddress) {
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    if(result == HasActionsIF::EXECUTION_FINISHED) {
+        CommandMessage reply;
+        ActionMessage::setCompletionReply(&reply, actionId, true, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
 }
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
-	//True aperiodic replies need to be reported with another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
+        ActionId_t replyId, SerializeIF* data, bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    uint8_t *dataPtr;
+    size_t maxSize = data->getSerializedSize();
+    if (maxSize == 0) {
+        /* No error, there's simply nothing to report. */
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    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
+        return result;
+    }
+    result = data->serialize(&dataPtr, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
 
-	//TODO Service Implementation sucks at the moment
-	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	} else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
-	if ( result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
 }
 
 void ActionHelper::resetHelper() {
 }
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+        ActionId_t replyId, const uint8_t *data, size_t dataSize,
+        bool hideSender) {
+    CommandMessage reply;
+    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
+        return result;
+    }
+
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}

action/ActionHelper.h

@@ -1,93 +1,126 @@
-#ifndef ACTIONHELPER_H_
-#define ACTIONHELPER_H_
+#ifndef FSFW_ACTION_ACTIONHELPER_H_
+#define FSFW_ACTION_ACTIONHELPER_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/ipc/MessageQueueIF.h>
+#include "ActionMessage.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MessageQueueIF.h"
 /**
- * \brief Action Helper is a helper class which handles action messages
+ * @brief Action Helper is a helper class which handles action messages
  *
- * Components which use the HasActionIF this helper can be used to handle the action messages.
- * It does handle step messages as well as other answers to action calls. It uses the executeAction function
- * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
+ * Components which use the HasActionIF this helper can be used to handle
+ * the action messages.
+ * It does handle step messages as well as other answers to action calls.
+ * It uses the executeAction function of its owner as callback.
+ * The call of the initialize function is mandatory and needs a
+ * valid MessageQueueIF pointer!
  */
 class HasActionsIF;
 
 class ActionHelper {
 public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    /**
+     * Constructor of the action helper
+     * @param setOwner Pointer to the owner of the interface
+     * @param useThisQueue  messageQueue to be used, can be set during
+     *                      initialize function as well.
+     */
+    ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
 
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other helper function
-	 * @param queueToUse_ Pointer to the messageQueue to be used
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
-	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
+    virtual ~ActionHelper();
+    /**
+     * Function to be called from the owner with a new command message
+     *
+     * If the message is a valid action message the helper will use the
+     * executeAction function from HasActionsIF.
+     * If the message is invalid or the callback fails a message reply will be
+     * send to the sender of the message automatically.
+     *
+     * @param command Pointer to a command message received by the owner
+     * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+     *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+     */
+    ReturnValue_t handleActionMessage(CommandMessage* command);
+    /**
+     * Helper initialize function. Must be called before use of any other
+     * helper function
+     * @param queueToUse_   Pointer to the messageQueue to be used, optional
+     *                      if queue was set in constructor
+     * @return Returns RETURN_OK if successful
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+    /**
+     * Function to be called from the owner to send a step message.
+     * Success or failure will be determined by the result value.
+     *
+     * @param step Number of steps already done
+     * @param reportTo The messageQueueId to report the step message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void step(uint8_t step, MessageQueueId_t reportTo,
+            ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner to send a action completion message
+     * @param success   Specify whether action was completed successfully or not.
+     * @param reportTo MessageQueueId_t to report the action completion message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes a SerializeIF* pointer and serializes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            SerializeIF* data, bool hideSender = false);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes the raw data and writes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            const uint8_t* data, size_t dataSize, bool hideSender = false);
+    /**
+     * Function to setup the MessageQueueIF* of the helper. Can be used to
+     * set the MessageQueueIF* if message queue is unavailable at construction
+     * and initialize but must be setup before first call of other functions.
+     * @param queue Queue to be used by the helper
+     */
+    void setQueueToUse(MessageQueueIF *queue);
 protected:
-	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
-	HasActionsIF* owner;//!< Pointer to the owner
-	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
-	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
-	/**
-	 *Internal function called by handleActionMessage(CommandMessage* command)
-	 *
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 *
-	 */
-	virtual void resetHelper();
+    //! Increase of value of this per step
+    static const uint8_t STEP_OFFSET = 1;
+    //! Pointer to the owner
+    HasActionsIF* owner;
+    //! Queue to be used as response sender, has to be set in ctor or with
+    //! setQueueToUse
+    MessageQueueIF* queueToUse;
+    //! Pointer to an IPC Store, initialized during construction or
+    StorageManagerIF* ipcStore = nullptr;
+
+    /**
+     * Internal function called by handleActionMessage
+     * @param commandedBy MessageQueueID of Commander
+     * @param actionId ID of action to be done
+     * @param dataAddress Address of additional data in IPC Store
+     */
+    virtual void prepareExecution(MessageQueueId_t commandedBy,
+            ActionId_t actionId, store_address_t dataAddress);
+    /**
+     * @brief Default implementation is empty.
+     */
+    virtual void resetHelper();
 };
 
-#endif /* ACTIONHELPER_H_ */
+#endif /* FSFW_ACTION_ACTIONHELPER_H_ */

action/ActionMessage.cpp

@@ -1,6 +1,8 @@
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
+#include "ActionMessage.h"
+#include "HasActionsIF.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
 
 ActionMessage::ActionMessage() {
 }
@@ -9,71 +11,72 @@ ActionMessage::~ActionMessage() {
 }
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
+        store_address_t parameters) {
+    message->setCommand(EXECUTE_ACTION);
+    message->setParameter(fid);
+    message->setParameter2(parameters.raw);
 }
 
 ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
+    return ActionId_t(message->getParameter());
 }
 
 store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
+    store_address_t temp;
+    temp.raw = message->getParameter2();
+    return temp;
 }
 
 void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
+        ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        message->setCommand(STEP_SUCCESS);
+    } else {
+        message->setCommand(STEP_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2((step << 16) + result);
 }
 
 uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+    return uint8_t((message->getParameter2() >> 16) & 0xFF);
 }
 
 ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
+    return message->getParameter2() & 0xFFFF;
 }
 
 void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
+        store_address_t data) {
+    message->setCommand(DATA_REPLY);
+    message->setParameter(actionId);
+    message->setParameter2(data.raw);
 }
 
 void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
+        ActionId_t fid, bool success, ReturnValue_t result) {
+    if (success) {
+        message->setCommand(COMPLETION_SUCCESS);
+    }
+    else {
+        message->setCommand(COMPLETION_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2(result);
 }
 
 void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
+    switch(message->getCommand()) {
+    case EXECUTE_ACTION:
+    case DATA_REPLY: {
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != NULL) {
+            ipcStore->deleteData(getStoreId(message));
+        }
+        break;
+    }
+    default:
+        break;
+    }
 }

action/ActionMessage.h

@@ -1,32 +1,47 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
+#ifndef FSFW_ACTION_ACTIONMESSAGE_H_
+#define FSFW_ACTION_ACTIONMESSAGE_H_
 
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-typedef uint32_t ActionId_t;
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
 
+using ActionId_t = uint32_t;
+
+/**
+ * @brief   These messages are part of the action module of the FSFW.
+ * @details
+ * These messages are sent amongst objects implementing the HasActionsIF. Classes like the
+ * ActionHelper are able to process these messages.
+ */
 class ActionMessage {
 private:
-	ActionMessage();
+    ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
+    static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+    static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+    static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+    static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+    static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+    static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+    static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+
+    virtual ~ActionMessage();
+    static void setCommand(CommandMessage* message, ActionId_t fid,
+            store_address_t parameters);
+
+    static ActionId_t getActionId(const CommandMessage* message );
+    static store_address_t getStoreId(const CommandMessage* message);
+
+    static void setStepReply(CommandMessage* message, ActionId_t fid,
+            uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static uint8_t getStep(const CommandMessage* message );
+    static ReturnValue_t getReturnCode(const CommandMessage* message );
+    static void setDataReply(CommandMessage* message, ActionId_t actionId,
+            store_address_t data);
+    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+            bool success, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+
+    static void clear(CommandMessage* message);
 };
 
-#endif /* ACTIONMESSAGE_H_ */
+#endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */

action/CMakeLists.txt

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

action/CommandActionHelper.cpp

@@ -1,127 +1,127 @@
-#include <framework/action/ActionMessage.h>
-#include <framework/action/CommandActionHelper.h>
-#include <framework/action/CommandsActionsIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
+#include "ActionMessage.h"
+#include "CommandActionHelper.h"
+#include "CommandsActionsIF.h"
+#include "HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
+        owner(setOwner), queueToUse(NULL), ipcStore(
+        NULL), commandCount(0), lastTarget(0) {
 }
 
 CommandActionHelper::~CommandActionHelper() {
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, SerializeIF *data) {
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    uint8_t *storePointer;
+    size_t maxSize = data->getSerializedSize();
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+            &storePointer);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t size = 0;
+    result = data->serialize(&storePointer, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//    if (commandCount != 0) {
+//        return CommandsFunctionsIF::ALREADY_COMMANDING;
+//    }
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
+        ActionId_t actionId, store_address_t storeId) {
+    CommandMessage command;
+    ActionMessage::setCommand(&command, actionId, storeId);
+    ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeId);
+    }
+    lastTarget = queueId;
+    commandCount++;
+    return result;
 }
 
 ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    queueToUse = owner->getCommandQueuePtr();
+    if (queueToUse == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    if (reply->getSender() != lastTarget) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    switch (reply->getCommand()) {
+    case ActionMessage::COMPLETION_SUCCESS:
+        commandCount--;
+        owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::COMPLETION_FAILED:
+        commandCount--;
+        owner->completionFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_SUCCESS:
+        owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_FAILED:
+        commandCount--;
+        owner->stepFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::DATA_REPLY:
+        extractDataForOwner(ActionMessage::getActionId(reply),
+                ActionMessage::getStoreId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
+    return commandCount;
 }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
+    const uint8_t * data = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+    }
+    owner->dataReceived(actionId, data, size);
+    ipcStore->deleteData(storeId);
 }

action/CommandActionHelper.h

@@ -1,36 +1,36 @@
 #ifndef COMMANDACTIONHELPER_H_
 #define COMMANDACTIONHELPER_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/ipc/MessageQueueIF.h>
+#include "ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
 
 class CommandsActionsIF;
 
 class CommandActionHelper {
-	friend class CommandsActionsIF;
+    friend class CommandsActionsIF;
 public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
+    CommandActionHelper(CommandsActionsIF* owner);
+    virtual ~CommandActionHelper();
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, const uint8_t* data, uint32_t size);
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, SerializeIF* data);
+    ReturnValue_t initialize();
+    ReturnValue_t handleReply(CommandMessage* reply);
+    uint8_t getCommandCount() const;
 private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
+    CommandsActionsIF* owner;
+    MessageQueueIF* queueToUse;
+    StorageManagerIF* ipcStore;
+    uint8_t commandCount;
+    MessageQueueId_t lastTarget;
+    void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+    ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+            store_address_t storeId);
 };
 
 #endif /* COMMANDACTIONHELPER_H_ */

action/CommandsActionsIF.h

@@ -1,9 +1,9 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
+#ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
+#define FSFW_ACTION_COMMANDSACTIONSIF_H_
 
-#include <framework/action/CommandActionHelper.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
+#include "CommandActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
 
 /**
  * Interface to separate commanding actions of other objects.
@@ -15,20 +15,23 @@
  * - replyReceived(id, step, cause) (if cause == OK, it's a success).
  */
 class CommandsActionsIF {
-	friend class CommandActionHelper;
+    friend class CommandActionHelper;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
+    static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+    virtual ~CommandsActionsIF() {}
+    virtual MessageQueueIF* getCommandQueuePtr() = 0;
 protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
+    virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+    virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+            ReturnValue_t returnCode) = 0;
+    virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+            uint32_t size) = 0;
+    virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+    virtual void completionFailedReceived(ActionId_t actionId,
+            ReturnValue_t returnCode) = 0;
 };
 
 
-#endif /* COMMANDSACTIONSIF_H_ */
+#endif /* FSFW_ACTION_COMMANDSACTIONSIF_H_ */

action/HasActionsIF.h

@@ -1,11 +1,12 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+#ifndef FSFW_ACTION_HASACTIONSIF_H_
+#define FSFW_ACTION_HASACTIONSIF_H_
+
+#include "ActionHelper.h"
+#include "ActionMessage.h"
+#include "SimpleActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
 
-#include <framework/action/ActionHelper.h>
-#include <framework/action/ActionMessage.h>
-#include <framework/action/SimpleActionHelper.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
 /**
  * @brief
  * Interface for component which uses actions
@@ -34,27 +35,29 @@
  */
 class HasActionsIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-	virtual ~HasActionsIF() { }
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
-	 * be done. When needing more steps, return RETURN_OK and issue steps and
-	 * completion manually.
-	 * One "step failed" or completion report must be issued!
-	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+    static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+    static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+    static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+    virtual ~HasActionsIF() { }
+    /**
+     * Function to get the MessageQueueId_t of the implementing object
+     * @return MessageQueueId_t of the object
+     */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
+    /**
+     * Execute or initialize the execution of a certain function.
+     * The ActionHelpers will execute this function and behave differently
+     * depending on the returnvalue.
+     *
+     * @return
+     * -@c EXECUTION_FINISHED Finish reply will be generated
+     * -@c Not RETURN_OK Step failure reply will be generated
+     */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#endif /* FSFW_ACTION_HASACTIONSIF_H_ */

action/SimpleActionHelper.cpp

@@ -1,74 +1,75 @@
-#include <framework/action/HasActionsIF.h>
-#include <framework/action/SimpleActionHelper.h>
+#include "HasActionsIF.h"
+#include "SimpleActionHelper.h"
+
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
+        MessageQueueIF* useThisQueue) :
+        ActionHelper(setOwner, useThisQueue), isExecuting(false) {
 }
 
 SimpleActionHelper::~SimpleActionHelper() {
 }
 
 void SimpleActionHelper::step(ReturnValue_t result) {
-	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
+    // STEP_OFFESET is subtracted to compensate for adding offset in base
+    // method, which is not necessary here.
+    ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+            result);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        resetHelper();
+    }
 }
 
 void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
+    ActionHelper::finish(lastCommander, lastAction, result);
+    resetHelper();
 }
 
 ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
+    return ActionHelper::reportData(lastCommander, lastAction, data);
 }
 
 void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
+    stepCount = 0;
+    isExecuting = false;
+    lastAction = 0;
+    lastCommander = 0;
 }
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
+        ActionId_t actionId, store_address_t dataAddress) {
+    CommandMessage reply;
+    if (isExecuting) {
+        ipcStore->deleteData(dataAddress);
+        ActionMessage::setStepReply(&reply, actionId, 0,
+                HasActionsIF::IS_BUSY);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    lastCommander = commandedBy;
+    lastAction = actionId;
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    switch (result) {
+    case HasReturnvaluesIF::RETURN_OK:
+        isExecuting = true;
+        stepCount++;
+        break;
+    case HasActionsIF::EXECUTION_FINISHED:
+        ActionMessage::setCompletionReply(&reply, actionId,
+                true, HasReturnvaluesIF::RETURN_OK);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    default:
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    }
 
 }

action/SimpleActionHelper.h

@@ -1,24 +1,30 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
+#ifndef FSFW_ACTION_SIMPLEACTIONHELPER_H_
+#define FSFW_ACTION_SIMPLEACTIONHELPER_H_
 
-#include <framework/action/ActionHelper.h>
+#include "ActionHelper.h"
 
+/**
+ * @brief    This is an action helper which is only able to service one action
+ *             at a time but remembers last commander and last action which
+ *             simplifies usage
+ */
 class SimpleActionHelper: public ActionHelper {
 public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
+    SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    virtual ~SimpleActionHelper();
+    void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    ReturnValue_t reportData(SerializeIF* data);
 
 protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	virtual  void resetHelper();
+    void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+            store_address_t dataAddress);
+    virtual void resetHelper();
 private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander;
-	ActionId_t lastAction;
-	uint8_t stepCount;
+    bool isExecuting;
+    MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+    ActionId_t lastAction = 0;
+    uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */

container/ArrayList.h

@@ -1,12 +1,12 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#ifndef FSFW_CONTAINER_ARRAYLIST_H_
+#define FSFW_CONTAINER_ARRAYLIST_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
 
 /**
- * @brief 	A List that stores its values in an array.
+ * @brief     A List that stores its values in an array.
  * @details
  * The underlying storage is an array that can be allocated by the class
  * itself or supplied via ctor.
@@ -15,57 +15,57 @@
  */
 template<typename T, typename count_t = uint8_t>
 class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
+    template<typename U, typename count> friend class SerialArrayListAdapter;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+    static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+
+    /**
+     * This is the allocating constructor.
+     * It allocates an array of the specified size.
+     * @param maxSize
+     */
+    ArrayList(count_t maxSize) :
+        size(0), maxSize_(maxSize), allocated(true) {
+        entries = new T[maxSize];
+    }
+
+    /**
+     * This is the non-allocating constructor
+     *
+     * It expects a pointer to an array of a certain size and initializes
+     * itself to it.
+     *
+     * @param storage the array to use as backend
+     * @param maxSize size of storage
+     * @param size size of data already present in storage
+     */
+    ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+        size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+    }
 
     /**
      * Copying is forbiden by declaring copy ctor and copy assignment deleted
      * It is too ambigous in this case.
      * (Allocate a new backend? Use the same? What to do in an modifying call?)
      */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
+    ArrayList(const ArrayList& other) = delete;
+    const ArrayList& operator=(const ArrayList& other) = delete;
 
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
+    /**
+     * Number of Elements stored in this List
+     */
+    count_t size;
 
-	/**
-	 * This is the allocating constructor;
-	 *
-	 * It allocates an array of the specified size.
-	 *
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-			size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
 
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
-
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
+    /**
+     * Destructor, if the allocating constructor was used, it deletes the array.
+     */
+    virtual ~ArrayList() {
+        if (allocated) {
+            delete[] entries;
+        }
+    }
 
     /**
      * An Iterator to go trough an ArrayList
@@ -116,7 +116,11 @@ public:
             return tmp;
         }
 
-        T operator*() {
+        T& operator*() {
+            return *value;
+        }
+
+        const T& operator*() const {
             return *value;
         }
 
@@ -124,124 +128,126 @@ public:
             return value;
         }
 
-        const T *operator->() const{
+        const T *operator->() const {
             return value;
         }
-
-        //SHOULDDO this should be implemented as non-member
-        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
-            return (value == other.value);
-        }
-
-        //SHOULDDO this should be implemented as non-member
-        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-            return !(*this == other);
-        }
     };
 
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
+    friend bool operator==(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
+    friend bool operator!=(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
+    /**
+     * Iterator pointing to the first stored elmement
+     *
+     * @return Iterator to the first element
+     */
+    Iterator begin() const {
+        return Iterator(&entries[0]);
+    }
 
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
+    /**
+     * returns an Iterator pointing to the element after the last stored entry
+     *
+     * @return Iterator to the element after the last entry
+     */
+    Iterator end() const {
+        return Iterator(&entries[size]);
+    }
 
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
+    T & operator[](count_t i) const {
+        return entries[i];
+    }
 
-	const T* back() const{
-		return &entries[size-1];
-	}
+    /**
+     * The first element
+     *
+     * @return pointer to the first stored element
+     */
+    T *front() {
+        return entries;
+    }
 
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	uint32_t maxSize() const {
-		return this->maxSize_;
-	}
+    /**
+     * The last element
+     *
+     * does not return a valid pointer if called on an empty list.
+     *
+     * @return pointer to the last stored element
+     */
+    T *back() {
+        return &entries[size - 1];
+        //Alternative solution
+        //return const_cast<T*>(static_cast<const T*>(*this).back());
+    }
 
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    const T* back() const{
+        return &entries[size-1];
+    }
 
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
+    /**
+     * The maximum number of elements this List can contain
+     *
+     * @return maximum number of elements
+     */
+    size_t maxSize() const {
+        return this->maxSize_;
+    }
 
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
+    /**
+     * Insert a new element into the list.
+     *
+     * The new element is inserted after the last stored element.
+     *
+     * @param entry
+     * @return
+     *          -@c FULL if the List is full
+     *          -@c RETURN_OK else
+     */
+    ReturnValue_t insert(T entry) {
+        if (size >= maxSize_) {
+            return FULL;
+        }
+        entries[size] = entry;
+        ++size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    /**
+     * clear the List
+     *
+     * This does not actually clear all entries, it only sets the size to 0.
+     */
+    void clear() {
+        size = 0;
+    }
+
+    count_t remaining() {
+        return (maxSize_ - size);
+    }
 
 protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	uint32_t maxSize_;
+    /**
+     * pointer to the array in which the entries are stored
+     */
+    T *entries;
+    /**
+     * remembering the maximum size
+     */
+    size_t maxSize_;
 
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
+    /**
+     * true if the array was allocated and needs to be deleted in the destructor.
+     */
+    bool allocated;
 };
 
-#endif /* ARRAYLIST_H_ */
+
+
+#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

container/BinaryTree.h

@@ -7,65 +7,65 @@
 template<typename Tp>
 class BinaryNode {
 public:
-	BinaryNode(Tp* setValue) :
-			value(setValue), left(NULL), right(NULL), parent(NULL) {
-	}
-	Tp *value;
-	BinaryNode* left;
-	BinaryNode* right;
-	BinaryNode* parent;
+    BinaryNode(Tp* setValue) :
+            value(setValue), left(NULL), right(NULL), parent(NULL) {
+    }
+    Tp *value;
+    BinaryNode* left;
+    BinaryNode* right;
+    BinaryNode* parent;
 };
 
 template<typename Tp>
 class ExplicitNodeIterator {
 public:
-	typedef ExplicitNodeIterator<Tp> _Self;
-	typedef BinaryNode<Tp> _Node;
-	typedef Tp value_type;
-	typedef Tp* pointer;
-	typedef Tp& reference;
-	ExplicitNodeIterator() :
-			element(NULL) {
-	}
-	ExplicitNodeIterator(_Node* node) :
-			element(node) {
-	}
-	BinaryNode<Tp>* element;
-	_Self up() {
-		return _Self(element->parent);
-	}
-	_Self left() {
-		if (element != NULL) {
-			return _Self(element->left);
-		} else {
-			return _Self(NULL);
-		}
+    typedef ExplicitNodeIterator<Tp> _Self;
+    typedef BinaryNode<Tp> _Node;
+    typedef Tp value_type;
+    typedef Tp* pointer;
+    typedef Tp& reference;
+    ExplicitNodeIterator() :
+            element(NULL) {
+    }
+    ExplicitNodeIterator(_Node* node) :
+            element(node) {
+    }
+    BinaryNode<Tp>* element;
+    _Self up() {
+        return _Self(element->parent);
+    }
+    _Self left() {
+        if (element != NULL) {
+            return _Self(element->left);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	_Self right() {
-		if (element != NULL) {
-			return _Self(element->right);
-		} else {
-			return _Self(NULL);
-		}
+    }
+    _Self right() {
+        if (element != NULL) {
+            return _Self(element->right);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	bool operator==(const _Self& __x) const {
-		return element == __x.element;
-	}
-	bool operator!=(const _Self& __x) const {
-		return element != __x.element;
-	}
+    }
+    bool operator==(const _Self& __x) const {
+        return element == __x.element;
+    }
+    bool operator!=(const _Self& __x) const {
+        return element != __x.element;
+    }
     pointer
     operator->() const {
-    	if (element != NULL) {
-    		return element->value;
-    	} else {
-    		return NULL;
-    	}
+        if (element != NULL) {
+            return element->value;
+        } else {
+            return NULL;
+        }
     }
     pointer operator*() const {
-    	return this->operator->();
+        return this->operator->();
     }
 };
 
@@ -75,77 +75,77 @@ public:
 template<typename Tp>
 class BinaryTree {
 public:
-	typedef ExplicitNodeIterator<Tp> iterator;
-	typedef BinaryNode<Tp> Node;
-	typedef std::pair<iterator, iterator> children;
-	BinaryTree() :
-			rootNode(NULL) {
-	}
-	BinaryTree(Node* rootNode) :
-			rootNode(rootNode) {
-	}
-	iterator begin() const {
-		return iterator(rootNode);
-	}
-	static iterator end() {
-		return iterator(NULL);
-	}
-	iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
-		newNode->parent = parentNode.element;
-		if (parentNode.element != NULL) {
-			if (insertLeft) {
-				parentNode.element->left = newNode;
-			} else {
-				parentNode.element->right = newNode;
-			}
-		} else {
-			//Insert first element.
-			rootNode = newNode;
-		}
-		return iterator(newNode);
-	}
-	//No recursion to children. Needs to be done externally.
-	children erase(iterator node) {
-		if (node.element == rootNode) {
-			//We're root node
-			rootNode = NULL;
-		} else {
-			//Delete parent's reference
-			if (node.up().left() == node) {
-				node.up().element->left = NULL;
-			} else {
-				node.up().element->right = NULL;
-			}
-		}
-		return children(node.element->left, node.element->right);
-	}
-	static uint32_t countLeft(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.left() != end()) {
-			count++;
-			start = start.left();
-		}
-		return count;
-	}
-	static uint32_t countRight(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.right() != end()) {
-			count++;
-			start = start.right();
-		}
-		return count;
-	}
+    typedef ExplicitNodeIterator<Tp> iterator;
+    typedef BinaryNode<Tp> Node;
+    typedef std::pair<iterator, iterator> children;
+    BinaryTree() :
+            rootNode(NULL) {
+    }
+    BinaryTree(Node* rootNode) :
+            rootNode(rootNode) {
+    }
+    iterator begin() const {
+        return iterator(rootNode);
+    }
+    static iterator end() {
+        return iterator(NULL);
+    }
+    iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
+        newNode->parent = parentNode.element;
+        if (parentNode.element != NULL) {
+            if (insertLeft) {
+                parentNode.element->left = newNode;
+            } else {
+                parentNode.element->right = newNode;
+            }
+        } else {
+            //Insert first element.
+            rootNode = newNode;
+        }
+        return iterator(newNode);
+    }
+    //No recursion to children. Needs to be done externally.
+    children erase(iterator node) {
+        if (node.element == rootNode) {
+            //We're root node
+            rootNode = NULL;
+        } else {
+            //Delete parent's reference
+            if (node.up().left() == node) {
+                node.up().element->left = NULL;
+            } else {
+                node.up().element->right = NULL;
+            }
+        }
+        return children(node.element->left, node.element->right);
+    }
+    static uint32_t countLeft(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.left() != end()) {
+            count++;
+            start = start.left();
+        }
+        return count;
+    }
+    static uint32_t countRight(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.right() != end()) {
+            count++;
+            start = start.right();
+        }
+        return count;
+    }
 
 protected:
-	Node* rootNode;
+    Node* rootNode;
 };
 
 

container/CMakeLists.txt

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

container/DynamicFIFO.h

@@ -1,12 +1,12 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#ifndef FSFW_CONTAINER_DYNAMICFIFO_H_
+#define FSFW_CONTAINER_DYNAMICFIFO_H_
 
-#include <framework/container/FIFOBase.h>
+#include "FIFOBase.h"
 #include <vector>
 
 /**
- * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor.
+ * @brief     Simple First-In-First-Out data structure. The maximum size
+ *             can be set in the constructor.
  * @details
  * The maximum capacity can be determined at run-time, so this container
  * performs dynamic memory allocation!
@@ -17,26 +17,39 @@
 template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(nullptr, maxCapacity),
-			fifoVector(maxCapacity)  {
-		// trying to pass the pointer of the uninitialized vector
-		// to the FIFOBase constructor directly lead to a super evil bug.
-		// So we do it like this now.
-		this->setData(fifoVector.data());
-	};
-
-	/**
-	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong.
-	 */
-	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
-			fifoVector(other.maxCapacity) {
-		this->setData(fifoVector.data());
-	}
+    DynamicFIFO(size_t maxCapacity): FIFOBase<T>(nullptr, maxCapacity),
+            fifoVector(maxCapacity)  {
+        // trying to pass the pointer of the uninitialized vector
+        // to the FIFOBase constructor directly lead to a super evil bug.
+        // So we do it like this now.
+        this->setContainer(fifoVector.data());
+    };
 
+    /**
+     * @brief    Custom copy constructor which prevents setting the
+     *             underlying pointer wrong. This function allocates memory!
+     * @details This is a very heavy operation so try to avoid this!
+     *
+     */
+    DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+            fifoVector(other.maxCapacity) {
+        this->fifoVector = other.fifoVector;
+        this->setContainer(fifoVector.data());
+    }
 
+    /**
+     * @brief Custom assignment operator
+     * @details This is a very heavy operation so try to avoid this!
+     * @param other DyamicFIFO to copy from
+     */
+    DynamicFIFO& operator=(const DynamicFIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoVector = other.fifoVector;
+        this->setContainer(fifoVector.data());
+        return *this;
+    }
 private:
-	std::vector<T> fifoVector;
+    std::vector<T> fifoVector;
 };
 
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */

container/FIFO.h

@@ -1,13 +1,12 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
+#ifndef FSFW_CONTAINER_FIFO_H_
+#define FSFW_CONTAINER_FIFO_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/FIFOBase.h>
+#include "FIFOBase.h"
 #include <array>
 
 /**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
+ * @brief     Simple First-In-First-Out data structure with size fixed at
+ *             compile time
  * @details
  * Performs no dynamic memory allocation.
  * The public interface of FIFOBase exposes the user interface for the FIFO.
@@ -17,18 +16,32 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+    FIFO(): FIFOBase<T>(nullptr, capacity) {
+        this->setContainer(fifoArray.data());
+    };
 
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->setData(fifoArray.data());
-	}
+    /**
+     * @brief     Custom copy constructor to set pointer correctly.
+     * @param other
+     */
+    FIFO(const FIFO& other): FIFOBase<T>(other) {
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+    }
+
+    /**
+     * @brief Custom assignment operator
+     * @param other
+     */
+    FIFO& operator=(const FIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+        return *this;
+    }
 
 private:
-	std::array<T, capacity> fifoArray;
+    std::array<T, capacity> fifoArray;
 };
 
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#endif /* FSFW_CONTAINER_FIFO_H_ */

container/FIFOBase.h

@@ -1,65 +1,79 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+#ifndef FSFW_CONTAINER_FIFOBASE_H_
+#define FSFW_CONTAINER_FIFOBASE_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 #include <cstring>
 
 template <typename T>
 class FIFOBase {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
 
-	/** Default ctor, takes pointer to first entry of underlying container
-	 *  and maximum capacity */
-	FIFOBase(T* values, const size_t maxCapacity);
+    /** Default ctor, takes pointer to first entry of underlying container
+     *  and maximum capacity */
+    FIFOBase(T* values, const size_t maxCapacity);
 
-	/**
-	 * Insert value into FIFO
-	 * @param value
-	 * @return
-	 */
-	ReturnValue_t insert(T value);
-	/**
-	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value
-	 * @return
-	 */
-	ReturnValue_t retrieve(T *value);
-	/**
-	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value
-	 * @return
-	 */
-	ReturnValue_t peek(T * value);
-	/**
-	 * Remove item from FIFO.
-	 * @return
-	 */
-	ReturnValue_t pop();
+    /**
+     * Insert value into FIFO
+     * @param value
+     * @return RETURN_OK on success, FULL if full
+     */
+    ReturnValue_t insert(T value);
+    /**
+     * Retrieve item from FIFO. This removes the item from the FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t retrieve(T *value);
+    /**
+     * Retrieve item from FIFO without removing it from FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t peek(T * value);
+    /**
+     * Remove item from FIFO.
+     * @return RETURN_OK on success, EMPTY if empty
+     */
+    ReturnValue_t pop();
 
-	bool empty();
-	bool full();
-	size_t size();
-
-
-	size_t getMaxCapacity() const;
+    /***
+     * Check if FIFO is empty
+     * @return True if empty, False if not
+     */
+    bool empty();
+    /***
+     * Check if FIFO is Full
+     * @return True if full, False if not
+     */
+    bool full();
+    /***
+     *  Current used size (elements) used
+     * @return size_t in elements
+     */
+    size_t size();
+    /***
+     * Get maximal capacity of fifo
+     * @return size_t with max capacity of this fifo
+     */
+    size_t getMaxCapacity() const;
 
 protected:
-	void setData(T* data);
-	size_t maxCapacity = 0;
+    void setContainer(T* data);
+    size_t maxCapacity = 0;
 
-	T* values;
+    T* values;
 
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
+    size_t readIndex = 0;
+    size_t writeIndex = 0;
+    size_t currentSize = 0;
 
-	size_t next(size_t current);
+    size_t next(size_t current);
 };
 
-#include <framework/container/FIFOBase.tpp>
+#include "FIFOBase.tpp"
 
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#endif /* FSFW_CONTAINER_FIFOBASE_H_ */

container/FIFOBase.tpp

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

container/FixedArrayList.h

@@ -1,56 +1,39 @@
 #ifndef FIXEDARRAYLIST_H_
 #define FIXEDARRAYLIST_H_
 
-#include <framework/container/ArrayList.h>
-
+#include "ArrayList.h"
+#include <cmath>
 /**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
+ * \ingroup container
  */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
+#if !defined(_MSC_VER)
+    static_assert(MAX_SIZE <= (std::pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+#endif
 private:
-	T data[MAX_SIZE];
+    T data[MAX_SIZE];
 public:
-	/**
-	 * (Robin) Maybe we should also implement move assignment and move ctor.
-	 * Or at least delete them.
-	 */
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
+    FixedArrayList() :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+    }
 
-	// (Robin): We could create a constructor to initialize the fixed array list
-	// with data and the known size field
-	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
-	// is this feasible?
-	/**
-	 * Initialize a fixed array list with data and number of data fields.
-	 * Endianness of entries can be swapped optionally.
-	 * @param data_
-	 * @param count
-	 * @param swapArrayListEndianess
-	 */
-	FixedArrayList(T * data_, count_t count):
-		ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, data_, count * sizeof(T));
-		this->size = count;
-	}
+    FixedArrayList(const FixedArrayList& other) :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+    }
 
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-	}
+    FixedArrayList& operator=(FixedArrayList other) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+        return *this;
+    }
 
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		return *this;
-	}
-
-	virtual ~FixedArrayList() {
-	}
+    virtual ~FixedArrayList() {
+    }
 
 };
 

container/FixedMap.h

@@ -1,225 +1,230 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDMAP_H_
+#define FSFW_CONTAINER_FIXEDMAP_H_
 
-#include <framework/container/ArrayList.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "ArrayList.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include <utility>
+#include <type_traits>
 
 /**
- * @brief 	Map implementation for maps with a pre-defined size.
- * @details Can be initialized with desired maximum size.
- * 	        Iterator is used to access <key,value> pair and
- * 	        iterate through map entries. Complexity O(n).
+ * @brief    Map implementation for maps with a pre-defined size.
+ * @details
+ * Can be initialized with desired maximum size.
+ * Iterator is used to access <key,value> pair and iterate through map entries.
+ * Complexity O(n).
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
  * @ingroup container
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
+    static_assert (std::is_trivially_copyable<T>::value or
+            std::is_base_of<SerializeIF, T>::value,
+            "Types used in FixedMap must either be trivial copy-able or a "
+            "derived class from SerializeIF to be serialize-able");
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+    static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+    static const key_t EMPTY_SLOT = -1;
+    ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+    uint32_t _size;
 
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
+    uint32_t findIndex(key_t key) const {
+        if (_size == 0) {
+            return 1;
+        }
+        uint32_t i = 0;
+        for (i = 0; i < _size; ++i) {
+            if (theMap[i].first == key) {
+                return i;
+            }
+        }
+        return i;
+    }
 public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
+    FixedMap(uint32_t maxSize) :
+            theMap(maxSize), _size(0) {
+    }
 
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        Iterator() :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
+        Iterator(std::pair<key_t, T> *pair) :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+        }
+    };
 
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
+    friend bool operator==(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
+    friend bool operator!=(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-		// Can be used to access the key of the iterator
-		key_t first() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
-		}
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-	};
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
+    uint32_t size() const {
+        return _size;
+    }
 
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+        if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+            return KEY_ALREADY_EXISTS;
+        }
+        if (_size == theMap.maxSize()) {
+            return MAP_FULL;
+        }
+        theMap[_size].first = key;
+        theMap[_size].second = value;
+        if (storedValue != nullptr) {
+            *storedValue = Iterator(&theMap[_size]);
+        }
+        ++_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    ReturnValue_t insert(std::pair<key_t, T> pair) {
+        return insert(pair.first, pair.second);
+    }
 
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    ReturnValue_t exists(key_t key) const {
+        ReturnValue_t result = KEY_DOES_NOT_EXIST;
+        if (findIndex(key) < _size) {
+            result = HasReturnvaluesIF::RETURN_OK;
+        }
+        return result;
+    }
 
-	uint32_t size() const {
-		return _size;
-	}
+    ReturnValue_t erase(Iterator *iter) {
+        uint32_t i;
+        if ((i = findIndex((*iter).value->first)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        --((*iter).value);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return FixedMap::KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return FixedMap::MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != NULL) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(key_t key) {
+        uint32_t i;
+        if ((i = findIndex(key)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
+    T *findValue(key_t key) const {
+        return &theMap[findIndex(key)].second;
+    }
 
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
+    Iterator find(key_t key) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findIndex(key)]);
+    }
 
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t find(key_t key, T **value) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        *value = &theMap[findIndex(key)].second;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    bool empty() {
+        if(_size == 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
+    void clear() {
+        _size = 0;
+    }
 
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    uint32_t maxSize() const {
+        return theMap.maxSize();
+    }
 
-	void clear() {
-		_size = 0;
-	}
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+                buffer, size, maxSize, streamEndianness);
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+                    size, maxSize, streamEndianness);
+            result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
+    virtual size_t getSerializedSize() const {
+        uint32_t printSize = sizeof(_size);
+        uint32_t i = 0;
 
+        for (i = 0; i < _size; ++i) {
+            printSize += SerializeAdapter::getSerializedSize(
+                    &theMap[i].first);
+            printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+        }
 
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
+        return printSize;
+    }
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
-
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+                buffer, size, streamEndianness);
+        if (this->_size > theMap.maxSize()) {
+            return SerializeIF::TOO_MANY_ELEMENTS;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+                    size, streamEndianness);
+            result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
 };
 
-#endif /* FIXEDMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

container/FixedOrderedMultimap.h

@@ -1,181 +1,207 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 
-#include <framework/container/ArrayList.h>
+#include "ArrayList.h"
 #include <cstring>
-#include <set>
+#include <functional>
+
 /**
+ * @brief  An associative container which allows multiple entries of the same key.
+ * @details
+ * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
+ *
+ * It uses the ArrayList, so technically this is not a real map, it is an array of pairs
+ * of type key_t, T. It is ordered by key_t as FixedMap but allows same keys. Thus it has a linear
+ * complexity O(n). As long as the number of entries remains low, this
+ * should not be an issue.
+ * The number of insertion and deletion operation should be minimized
+ * as those incur extensive memory move operations (the underlying container
+ * is not node based).
+ *
+ * Its of fixed size so no allocations are performed after the construction.
+ *
+ * The maximum size is given as first parameter of the constructor.
+ *
+ * It provides an iterator to do list iterations.
+ *
+ * The type T must have a copy constructor if it is not trivial copy-able.
+ *
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
+ *
  * \ingroup container
  */
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+
+    /***
+     * Constructor which needs a size_t for the maximum allowed size
+     *
+     * Can not be resized during runtime
+     *
+     * Allocates memory at construction
+     * @param maxSize size_t of Maximum allowed size
+     */
+    FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
+    }
+
+    /***
+     * Virtual destructor frees Memory by deleting its member
+     */
+    virtual ~FixedOrderedMultimap() {
+    }
+
+    /***
+     * Special iterator for FixedOrderedMultimap
+     */
+    class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
+    public:
+        Iterator() :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
+        }
+
+        Iterator(std::pair<key_t, T> *pair) :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
+        }
+    };
+
+    /***
+     * Returns an iterator pointing to the first element
+     * @return Iterator pointing to first element
+     */
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
+
+    /**
+     * Returns an iterator pointing to one element past the end
+     * @return Iterator pointing to one element past the end
+     */
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
+
+    /***
+     * Returns the current size of the map (not maximum size!)
+     * @return Current size
+     */
+    size_t size() const{
+        return _size;
+    }
+
+    /**
+     * Clears the map, does not deallocate any memory
+     */
+    void clear(){
+        _size = 0;
+    }
+
+    /**
+     * Returns the maximum size of the map
+     * @return Maximum size of the map
+     */
+    size_t maxSize() const{
+        return theMap.maxSize();
+    }
+
+    /***
+     * Used to insert a key and value separately.
+     *
+     * @param[in] key Key of the new element
+     * @param[in] value Value of the new element
+     * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+
+    /***
+     * Used to insert new pair instead of single values
+     *
+     * @param pair Pair to be inserted
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
+
+    /***
+     * Can be used to check if a certain key is in the map
+     * @param key Key to be checked
+     * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+     */
+    ReturnValue_t exists(key_t key) const;
+
+    /***
+     * Used to delete the element in the iterator
+     *
+     * The iterator will point to the element before or begin(),
+     *  but never to one element in front of the map.
+     *
+     * @warning The iterator needs to be valid and dereferenceable
+     * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(Iterator *iter);
+
+    /***
+     * Used to erase by key
+     * @param key Key to be erased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(key_t key);
+
+    /***
+     * Find returns the first appearance of the key
+     *
+     * If the key does not exist, it points to end()
+     *
+     * @param key Key to search for
+     * @return Iterator pointing to the first entry of key
+     */
+    Iterator find(key_t key) const{
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findFirstIndex(key)]);
+    };
+
+    /***
+     * Finds first entry of the given key and returns a
+     * pointer to the value
+     *
+     * @param key Key to search for
+     * @param value Found value
+     * @return RETURN_OK if it points to the value,
+     * KEY_DOES_NOT_EXIST if the key is not in the map
+     */
+    ReturnValue_t find(key_t key, T **value) const;
+
+    friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
+
+    friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
 private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+    typedef KEY_COMPARE compare;
+    compare myComp;
+    ArrayList<std::pair<key_t, T>, size_t> theMap;
+    size_t _size;
 
-	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
-		if (startAt >= _size) {
-			return startAt + 1;
-		}
-		uint32_t i = startAt;
-		for (i = startAt; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
+    size_t findFirstIndex(key_t key, size_t startAt = 0) const;
 
-	uint32_t findNicePlace(key_t key) const {
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (myComp(key, theMap[i].first)) {
-				return i;
-			}
-		}
-		return i;
-	}
-
-	void removeFromPosition(uint32_t position) {
-		if (_size <= position) {
-			return;
-		}
-		memmove(&theMap[position], &theMap[position + 1],
-				(_size - position - 1) * sizeof(std::pair<key_t,T>));
-		--_size;
-	}
-public:
-	FixedOrderedMultimap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-	virtual ~FixedOrderedMultimap() {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-	};
-
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		uint32_t position = findNicePlace(key);
-		memmove(&theMap[position + 1], &theMap[position],
-				(_size - position) * sizeof(std::pair<key_t,T>));
-		theMap[position].first = key;
-		theMap[position].second = value;
-		++_size;
-		if (storedValue != NULL) {
-			*storedValue = Iterator(&theMap[position]);
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findFirstIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		removeFromPosition(i);
-		if (*iter != begin()) {
-			(*iter)--;
-		} else {
-			*iter = begin();
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findFirstIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		do {
-			removeFromPosition(i);
-			i = findFirstIndex(key, i);
-		} while (i < _size);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	//This is potentially unsafe
-//	T *findValue(key_t key) const {
-//		return &theMap[findFirstIndex(key)].second;
-//	}
-
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findFirstIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
+    size_t findNicePlace(key_t key) const;
 
+    void removeFromPosition(size_t position);
 };
 
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
+#include "FixedOrderedMultimap.tpp"
+
+#endif /* FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */

container/FixedOrderedMultimap.tpp

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

container/HybridIterator.h

@@ -1,90 +1,90 @@
 #ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 #define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
-#include <framework/container/ArrayList.h>
-#include <framework/container/SinglyLinkedList.h>
+#include "ArrayList.h"
+#include "SinglyLinkedList.h"
 
 template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
+        public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() {}
+    HybridIterator() {}
 
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
+    HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+        LinkedElement<T>::Iterator(*iter), value(iter->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
+    HybridIterator(LinkedElement<T> *start) :
+        LinkedElement<T>::Iterator(start), value(start->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+            typename ArrayList<T, count_t>::Iterator end) :
+            ArrayList<T, count_t>::Iterator(start), value(start.value),
+            linked(false), end(end.value) {
+        if (value == this->end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(T *firstElement, T *lastElement) :
+            ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+            linked(false), end(++lastElement) {
+        if (value == end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
+    HybridIterator& operator++() {
+        if (linked) {
+            LinkedElement<T>::Iterator::operator++();
+            if (LinkedElement<T>::Iterator::value != nullptr) {
+                value = LinkedElement<T>::Iterator::value->value;
+            } else {
+                value = nullptr;
+            }
+        } else {
+            ArrayList<T, count_t>::Iterator::operator++();
+            value = ArrayList<T, count_t>::Iterator::value;
 
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
+            if (value == end) {
+                value = nullptr;
+            }
+        }
+        return *this;
+    }
 
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
+    HybridIterator operator++(int) {
+        HybridIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
 
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
+    bool operator==(const HybridIterator& other) const {
+        return value == other.value;
+    }
 
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
+    bool operator!=(const HybridIterator& other) const {
+        return !(*this == other);
+    }
 
-	T operator*() {
-		return *value;
-	}
+    T operator*() {
+        return *value;
+    }
 
-	T *operator->() {
-		return value;
-	}
+    T *operator->() {
+        return value;
+    }
 
-	T* value = nullptr;
+    T* value = nullptr;
 
 private:
-	bool linked = false;
-	T *end = nullptr;
+    bool linked = false;
+    T *end = nullptr;
 };
 
 #endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

container/IsDerivedFrom.h

@@ -1,50 +0,0 @@
-#ifndef ISDERIVEDFROM_H_
-#define ISDERIVEDFROM_H_
-
-/**
- * These template type checks are based on SFINAE
- * (https://en.cppreference.com/w/cpp/language/sfinae)
- *
- * @tparam D Derived Type
- * @tparam B Base Type
- */
-template<typename D, typename B>
-class IsDerivedFrom {
-	class No {
-	};
-	class Yes {
-		No no[3];
-	};
-
-	// This will be chosen if B is the base type
-	static Yes Test(B*); // declared, but not defined
-	// This will be chosen for anything else
-	static No Test(... ); // declared, but not defined
-
-public:
-	enum {
-		Is = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes)
-	};
-};
-
-template<typename, typename>
-struct is_same {
-    static bool const value = false;
-};
-
-template<typename A>
-struct is_same<A, A> {
-    static bool const value = true;
-};
-
-
-template<bool C, typename T = void>
-struct enable_if {
-  typedef T type;
-};
-
-template<typename T>
-struct enable_if<false, T> { };
-
-
-#endif /* ISDERIVEDFROM_H_ */

container/PlacementFactory.h

@@ -1,35 +1,71 @@
 #ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
 #define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
 
-#include <framework/storagemanager/StorageManagerIF.h>
+#include "../storagemanager/StorageManagerIF.h"
 #include <utility>
-
+/**
+ * The Placement Factory is used to create objects at runtime in a specific pool.
+ * In general, this should be avoided and it should only be used if you know what you are doing.
+ * You are not allowed to use this container with a type that allocates memory internally like ArrayList.
+ *
+ * Also, you have to check the returned pointer in generate against nullptr!
+ *
+ * A backend of Type StorageManagerIF must be given as a place to store the new objects.
+ * Therefore ThreadSafety is only provided by your StorageManager Implementation.
+ *
+ * Objects must be destroyed by the user with "destroy"! Otherwise the pool will not be cleared.
+ *
+ * The concept is based on the placement new operator.
+ *
+ * @warning Do not use with any Type that allocates memory internally!
+ * @ingroup container
+ */
 class PlacementFactory {
 public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = NULL;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return NULL;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
+    PlacementFactory(StorageManagerIF* backend) :
+            dataBackend(backend) {
+    }
+
+    /***
+     * Generates an object of type T in the backend storage.
+     *
+     * @warning Do not use with any Type that allocates memory internally!
+     *
+     * @tparam T Type of Object
+     * @param args Constructor Arguments to be passed
+     * @return A pointer to the new object or a nullptr in case of failure
+     */
+    template<typename T, typename ... Args>
+    T* generate(Args&&... args) {
+        store_address_t tempId;
+        uint8_t* pData = nullptr;
+        ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+                &pData);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return nullptr;
+        }
+        T* temp = new (pData) T(std::forward<Args>(args)...);
+        return temp;
+    }
+    /***
+     * Function to destroy the object allocated with generate and free space in backend.
+     * This must be called by the user.
+     *
+     * @param thisElement Element to be destroyed
+     * @return RETURN_OK if the element was destroyed, different errors on failure
+     */
+    template<typename T>
+    ReturnValue_t destroy(T* thisElement) {
+        if (thisElement == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+        thisElement->~T();
+        uint8_t* pointer = (uint8_t*) (thisElement);
+        return dataBackend->deleteData(pointer, sizeof(T));
+    }
 private:
-	StorageManagerIF* dataBackend;
+    StorageManagerIF* dataBackend;
 };
 
 #endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */

container/RingBufferBase.h

@@ -1,113 +1,113 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#ifndef FSFW_CONTAINER_RINGBUFFERBASE_H_
+#define FSFW_CONTAINER_RINGBUFFERBASE_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
+    RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+            start(startAddress), write(startAddress), size(size),
+            overwriteOld(overwriteOld) {
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = startAddress;
+        }
+    }
 
-	virtual ~RingBufferBase() {}
+    virtual ~RingBufferBase() {}
 
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
-	}
+    bool isFull(uint8_t n = 0) {
+        return (availableWriteSpace(n) == 0);
+    }
+    bool isEmpty(uint8_t n = 0) {
+        return (getAvailableReadData(n) == 0);
+    }
 
-	size_t availableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
+    size_t getAvailableReadData(uint8_t n = 0) const {
+        return ((write + size) - read[n]) % size;
+    }
+    size_t availableWriteSpace(uint8_t n = 0) const  {
+        //One less to avoid ambiguous full/empty problem.
+        return (((read[n] + size) - write - 1) % size);
+    }
 
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
+    bool overwritesOld() const {
+        return overwriteOld;
+    }
 
-	size_t maxSize() const {
-		return size - 1;
-	}
+    size_t getMaxSize() const {
+        return size - 1;
+    }
 
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
+    void clear() {
+        write = start;
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = start;
+        }
+    }
 
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
+    size_t writeTillWrap() {
+        return (start + size) - write;
+    }
 
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
+    size_t readTillWrap(uint8_t n = 0) {
+        return (start + size) - read[n];
+    }
 
-	size_t getStart() const {
-		return start;
-	}
+    size_t getStart() const {
+        return start;
+    }
 
 protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
+    const size_t start;
+    size_t write;
+    size_t read[N_READ_PTRS];
+    const size_t size;
+    const bool overwriteOld;
 
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (availableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    void incrementWrite(uint32_t amount) {
+        write = ((write + amount - start) % size) + start;
+    }
+    void incrementRead(uint32_t amount, uint8_t n = 0) {
+        read[n] = ((read[n] + amount - start) % size) + start;
+    }
 
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+        if (getAvailableReadData(n) >= amount) {
+            incrementRead(amount, n);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
+    ReturnValue_t writeData(uint32_t amount) {
+        if (availableWriteSpace() >= amount or overwriteOld) {
+            incrementWrite(amount);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
+    size_t getRead(uint8_t n = 0) const {
+        return read[n];
+    }
 
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
+    void setRead(uint32_t read, uint8_t n = 0) {
+        if (read >= start && read < (start+size)) {
+            this->read[n] = read;
+        }
+    }
 
-	uint32_t getWrite() const {
-		return write;
-	}
+    uint32_t getWrite() const {
+        return write;
+    }
 
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
+    void setWrite(uint32_t write) {
+        this->write = write;
+    }
 };
 
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */

container/RingBufferTest.cpp.ignore

@@ -1,79 +0,0 @@
-
-#include <iostream>
-#include "SimpleRingBuffer.h"
-
-
-int main() {
-	using namespace std;
-	SimpleRingBuffer buffer(64, false);
-	uint8_t data[8] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-	ReturnValue_t result = buffer.writeData(data, 8);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(data, 8);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	uint8_t buffer2[47] = {0};
-	for (uint8_t count = 0; count<sizeof(buffer2); count++) {
-		buffer2[count] = count;
-	}
-	result = buffer.writeData(buffer2, sizeof(buffer2));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(buffer2, sizeof(buffer2));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	uint8_t readBuffer[64] = {0};
-	uint32_t writtenData = 0;
-	result = buffer.readData(readBuffer, 12, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-
-	result = buffer.readData(readBuffer, 60, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-	result = buffer.writeData(data, sizeof(data));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.readData(readBuffer, 60, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-	result = buffer.writeData(readBuffer, sizeof(readBuffer));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(readBuffer, sizeof(readBuffer)-1);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	} else {
-		cout << "write done." << endl;
-	}
-}
-
-

container/SharedRingBuffer.cpp

@@ -1,59 +1,60 @@
-#include <framework/container/SharedRingBuffer.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
+#include "SharedRingBuffer.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexGuard.h"
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes, dur_millis_t mutexTimeout):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes), mutexTimeout(mutexTimeout) {
-	mutex = MutexFactory::instance()->createMutex();
+        bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
+
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes,
-		dur_millis_t mutexTimeout):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes), mutexTimeout(mutexTimeout) {
-	mutex = MutexFactory::instance()->createMutex();
+        const size_t size, bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
-ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
-		size_t amount) {
-	MutexHelper(mutex, mutexTimeout);
-	return SimpleRingBuffer::getFreeElement(writePtr,amount);
+SharedRingBuffer::~SharedRingBuffer() {
+    MutexFactory::instance()->deleteMutex(mutex);
 }
 
-ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
-		size_t amount) {
-	MutexHelper(mutex, mutexTimeout);
-	return SimpleRingBuffer::writeData(data,amount);
+void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
+    this->fifoDepth = fifoDepth;
 }
 
-ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
-		bool incrementReadPtr, bool readRemaining,
-		size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
-	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
-			readRemaining, trueAmount);
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
 }
 
-ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
-		bool deleteRemaining, size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
-	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
 }
 
-size_t SharedRingBuffer::getExcessBytes() const {
-	MutexHelper(mutex, mutexTimeout);
-	return SimpleRingBuffer::getExcessBytes();
+
+
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
 }
 
-void SharedRingBuffer::moveExcessBytesToStart() {
-	MutexHelper(mutex, mutexTimeout);
-	return SimpleRingBuffer::moveExcessBytesToStart();
+ReturnValue_t SharedRingBuffer::initialize() {
+    if(fifoDepth > 0) {
+        receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+    }
+    return SystemObject::initialize();
 }
 
-size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
-	MutexHelper(mutex, mutexTimeout);
-	return ((write + size) - read[n]) % size;
+DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
+    if(receiveSizesFIFO == nullptr) {
+        // Configuration error.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+                << " was not configured to have sizes FIFO, returning nullptr!"
+                << std::endl;
+#endif
+    }
+    return receiveSizesFIFO;
 }

container/SharedRingBuffer.h

@@ -1,68 +1,95 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+#define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
-#include <framework/container/SimpleRingBuffer.h>
-#include <framework/ipc/MutexIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/timemanager/Clock.h>
+#include "SimpleRingBuffer.h"
+#include "DynamicFIFO.h"
+#include "../ipc/MutexIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../timemanager/Clock.h"
 
+/**
+ * @brief   Ring buffer which can be shared among multiple objects
+ * @details
+ * This class offers a mutex to perform thread-safe operation on the ring
+ * buffer. It is still up to the developer to actually perform the lock
+ * and unlock operations.
+ */
 class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
+        public SimpleRingBuffer {
 public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes,
-			dur_millis_t mutexTimeout = 10);
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes,
-			dur_millis_t mutexTimeout = 10);
+    virtual~ SharedRingBuffer();
 
-	void setMutexTimeout(dur_millis_t newTimeout);
+    /**
+     * @brief    This function can be used to add an optional FIFO to the class
+     * @details 
+     * This FIFO will be allocated in the initialize function (and will
+     * have a fixed maximum size after that). It can be used to store
+     * values like packet sizes, for example for a shared ring buffer
+     * used by producer/consumer tasks.
+     */
+    void setToUseReceiveSizeFIFO(size_t fifoDepth);
 
-	virtual size_t getExcessBytes() const override;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart() override;
 
-	/** Performs mutex protected SimpleRingBuffer::getFreeElement call */
-	ReturnValue_t getFreeElementProtected(uint8_t** writePtr, size_t amount);
 
-	/** Performs mutex protected SimpleRingBuffer::writeData call */
-	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount);
+    /**
+     * Unless a read-only constant value is read, all operations on the
+     * shared ring buffer should be protected by calling this function.
+     * @param timeoutType
+     * @param timeout
+     * @return
+     */
+    virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+            dur_millis_t timeout);
+    /**
+     * Any locked mutex also has to be unlocked, otherwise, access to the
+     * shared ring buffer will be blocked.
+     * @return
+     */
+    virtual ReturnValue_t unlockRingBufferMutex();
 
-	/** Performs mutex protected SimpleRingBuffer::readData call */
-	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
-			bool incrementReadPtr = false,
-			bool readRemaining = false, size_t *trueAmount = nullptr);
+    /**
+     * The mutex handle can be accessed directly, for example to perform
+     * the lock with the #MutexGuard for a RAII compliant lock operation.
+     * @return
+     */
+    MutexIF* getMutexHandle() const;
 
-	/** Performs mutex protected SimpleRingBuffer::deleteData call */
-	ReturnValue_t deleteDataProtected(size_t amount,
-			bool deleteRemaining = false, size_t* trueAmount = nullptr);
+    ReturnValue_t initialize() override;
 
-	size_t getAvailableReadDataProtected (uint8_t n = 0) const;
+    /**
+     * If the shared ring buffer was configured to have a sizes FIFO, a handle
+     * to that FIFO can be retrieved with this function.
+     * Do not forget to protect access with a lock if required!
+     * @return
+     */
+    DynamicFIFO<size_t>* getReceiveSizesFIFO();
 private:
-	dur_millis_t mutexTimeout;
-	MutexIF* mutex = nullptr;
+    MutexIF* mutex = nullptr;
+
+    size_t fifoDepth = 0;
+    DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 
 
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#endif /* FSFW_CONTAINER_SHAREDRINGBUFFER_H_ */

container/SimpleRingBuffer.cpp

@@ -1,36 +1,34 @@
-#include <framework/container/SimpleRingBuffer.h>
+#include "SimpleRingBuffer.h"
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
+        size_t maxExcessBytes) :
+        RingBufferBase<>(0, size, overwriteOld),
+        maxExcessBytes(maxExcessBytes) {
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
+    buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
+        bool overwriteOld, size_t maxExcessBytes):
         RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
 }
 
-
 SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
+    delete[] buffer;
 }
 
-
 ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
         size_t amount) {
     if (availableWriteSpace() >= amount or overwriteOld) {
@@ -42,7 +40,6 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
             excessBytes = amount - amountTillWrap;
         }
         *writePointer = &buffer[write];
-        incrementWrite(amount);
         return HasReturnvaluesIF::RETURN_OK;
     }
     else {
@@ -50,51 +47,59 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
     }
 }
 
+void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
+    if(getExcessBytes() > 0) {
+        moveExcessBytesToStart();
+    }
+    incrementWrite(amount);
+
+}
+
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap >= amount) {
+            // remaining size in buffer is sufficient to fit full amount.
+            memcpy(&buffer[write], data, amount);
+        }
+        else {
+            memcpy(&buffer[write], data, amountTillWrap);
+            memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
+        }
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
+        bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    size_t amountTillWrap = readTillWrap(READ_PTR);
+    if (availableData < amount) {
+        if (readRemaining) {
+            // more data available than amount specified.
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    if (amountTillWrap >= amount) {
+        memcpy(data, &buffer[read[READ_PTR]], amount);
+    } else {
+        memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
+        memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
+    }
 
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if(incrementReadPtr) {
+        deleteData(amount, readRemaining);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 size_t SimpleRingBuffer::getExcessBytes() const {
@@ -109,19 +114,18 @@ void SimpleRingBuffer::moveExcessBytesToStart() {
 }
 
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
+        bool deleteRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    if (availableData < amount) {
+        if (deleteRemaining) {
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    incrementRead(amount, READ_PTR);
+    return HasReturnvaluesIF::RETURN_OK;
 }
-

container/SimpleRingBuffer.h

@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#ifndef FSFW_CONTAINER_SIMPLERINGBUFFER_H_
+#define FSFW_CONTAINER_SIMPLERINGBUFFER_H_
 
-#include <framework/container/RingBufferBase.h>
+#include "RingBufferBase.h"
 #include <cstddef>
 
 /**
- * @brief 	Circular buffer implementation, useful for buffering
+ * @brief     Circular buffer implementation, useful for buffering
  *          into data streams.
  * @details
  * Note that the deleteData() has to be called to increment the read pointer.
@@ -25,95 +25,105 @@ public:
      * with getFreeElement.
      *
      */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
+    SimpleRingBuffer(const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
      * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
+     * @param maxExcessBytes
+     * If the buffer can accomodate additional bytes for contigous write
+     * operations with getFreeElement, this is the maximum allowed additional
+     * size
+     */
+    SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
 
-	virtual ~SimpleRingBuffer();
+    virtual ~SimpleRingBuffer();
 
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
+    /**
+     * Write to circular buffer and increment write pointer by amount.
+     * @param data
+     * @param amount
+     * @return -@c RETURN_OK if write operation was successfull
+     * -@c RETURN_FAILED if
+     */
+    ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached.
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+    /**
+     * Returns a pointer to a free element. If the remaining buffer is
+     * not large enough, the data will be written past the actual size
+     * and the amount of excess bytes will be cached. This function
+     * does not increment the write pointer!
+     * @param writePointer Pointer to a pointer which can be used to write
+     * contiguous blocks into the ring buffer
+     * @param amount
+     * @return
+     */
+    ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
+    /**
+     * This increments the write pointer and also copies the excess bytes
+     * to the beginning. It should be called if the write operation
+     * conducted after calling getFreeElement() was performed.
+     * @return
+     */
+    void confirmBytesWritten(size_t amount);
 
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
+    virtual size_t getExcessBytes() const;
+    /**
+     * Helper functions which moves any excess bytes to the start
+     * of the ring buffer.
+     * @return
+     */
+    virtual void moveExcessBytesToStart();
+
+    /**
+     * Read from circular buffer at read pointer.
+     * @param data
+     * @param amount
+     * @param incrementReadPtr
+     * If this is set to true, the read pointer will be incremented.
+     * If readRemaining is set to true, the read pointer will be incremented
+     * accordingly.
+     * @param readRemaining
+     * If this is set to true, the data will be read even if the amount
+     * specified exceeds the read data available.
+     * @param trueAmount [out]
+     * If readRemaining was set to true, the true amount read will be assigned
+     * to the passed value.
+     * @return
+     * - @c RETURN_OK if data was read successfully
+     * - @c RETURN_FAILED if not enough data was available and readRemaining
+     *      was set to false.
+     */
+    ReturnValue_t readData(uint8_t* data, size_t amount,
+            bool incrementReadPtr = false, bool readRemaining = false,
+            size_t* trueAmount = nullptr);
+
+    /**
+     * Delete data by incrementing read pointer.
+     * @param amount
+     * @param deleteRemaining
+     * If the amount specified is larger than the remaing size to read and this
+     * is set to true, the remaining amount will be deleted as well
+     * @param trueAmount [out]
+     * If deleteRemaining was set to true, the amount deleted will be assigned
+     * to the passed value.
+     * @return
+     */
+    ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+            size_t* trueAmount = nullptr);
 
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
 private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
+    static const uint8_t READ_PTR = 0;
+    uint8_t* buffer = nullptr;
+    size_t maxExcessBytes;
+    size_t excessBytes = 0;
 };
 
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+#endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
 

container/SinglyLinkedList.h

@@ -5,71 +5,71 @@
 #include <cstdint>
 
 /**
- * @brief	Linked list data structure,
- * 			each entry has a pointer to the next entry (singly)
+ * @brief    Linked list data structure,
+ *             each entry has a pointer to the next entry (singly)
  * @ingroup container
  */
 template<typename T>
 class LinkedElement {
 public:
-	T *value;
-	class Iterator {
-	public:
-		LinkedElement<T> *value = nullptr;
-		Iterator() {}
+    T *value;
+    class Iterator {
+    public:
+        LinkedElement<T> *value = nullptr;
+        Iterator() {}
 
-		Iterator(LinkedElement<T> *element) :
-				value(element) {
-		}
+        Iterator(LinkedElement<T> *element) :
+                value(element) {
+        }
 
-		Iterator& operator++() {
-			value = value->getNext();
-			return *this;
-		}
+        Iterator& operator++() {
+            value = value->getNext();
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		bool operator==(Iterator other) {
-			return value == other.value;
-		}
+        bool operator==(Iterator other) {
+            return value == other.value;
+        }
 
-		bool operator!=(Iterator other) {
-			return !(*this == other);
-		}
-		T *operator->() {
-			return value->value;
-		}
-	};
+        bool operator!=(Iterator other) {
+            return !(*this == other);
+        }
+        T *operator->() {
+            return value->value;
+        }
+    };
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
-	       value(setElement), next(setNext) {}
+    LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+           value(setElement), next(setNext) {}
 
-	virtual ~LinkedElement(){}
+    virtual ~LinkedElement(){}
 
-	virtual LinkedElement* getNext() const {
-		return next;
-	}
+    virtual LinkedElement* getNext() const {
+        return next;
+    }
 
-	virtual void setNext(LinkedElement* next) {
-		this->next = next;
-	}
+    virtual void setNext(LinkedElement* next) {
+        this->next = next;
+    }
 
-	virtual void setEnd() {
-	    this->next = nullptr;
-	}
+    virtual void setEnd() {
+        this->next = nullptr;
+    }
 
-	LinkedElement* begin() {
-		return this;
-	}
-	LinkedElement* end() {
-		return nullptr;
-	}
+    LinkedElement* begin() {
+        return this;
+    }
+    LinkedElement* end() {
+        return nullptr;
+    }
 private:
-	LinkedElement *next;
+    LinkedElement *next;
 };
 
 template<typename T>
@@ -77,52 +77,52 @@ class SinglyLinkedList {
 public:
     using ElementIterator = typename LinkedElement<T>::Iterator;
 
-	SinglyLinkedList() {}
+    SinglyLinkedList() {}
 
-	SinglyLinkedList(ElementIterator start) :
-			start(start.value) {}
+    SinglyLinkedList(ElementIterator start) :
+            start(start.value) {}
 
-	SinglyLinkedList(LinkedElement<T>* startElement) :
-			start(startElement) {}
+    SinglyLinkedList(LinkedElement<T>* startElement) :
+            start(startElement) {}
 
-	ElementIterator begin() const {
-		return ElementIterator::Iterator(start);
-	}
+    ElementIterator begin() const {
+        return ElementIterator::Iterator(start);
+    }
 
-	/** Returns iterator to nulltr */
-	ElementIterator end() const {
-		return ElementIterator::Iterator();
-	}
+    /** Returns iterator to nulltr */
+    ElementIterator end() const {
+        return ElementIterator::Iterator();
+    }
 
-	/**
-	 * Returns last element in singly linked list.
-	 * @return
-	 */
-	ElementIterator back() const {
-	    LinkedElement<T> *element = start;
-	    while (element != nullptr) {
-	        element = element->getNext();
-	    }
-	    return ElementIterator::Iterator(element);
-	}
+    /**
+     * Returns last element in singly linked list.
+     * @return
+     */
+    ElementIterator back() const {
+        LinkedElement<T> *element = start;
+        while (element->getNext() != nullptr) {
+            element = element->getNext();
+        }
+        return ElementIterator::Iterator(element);
+    }
 
-	size_t getSize() const {
-		size_t size = 0;
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			size++;
-			element = element->getNext();
-		}
-		return size;
-	}
-	void setStart(LinkedElement<T>* firstElement) {
-		start = firstElement;
-	}
+    size_t getSize() const {
+        size_t size = 0;
+        LinkedElement<T> *element = start;
+        while (element != nullptr) {
+            size++;
+            element = element->getNext();
+        }
+        return size;
+    }
+    void setStart(LinkedElement<T>* firstElement) {
+        start = firstElement;
+    }
 
-	void setNext(LinkedElement<T>* currentElement,
-	        LinkedElement<T>* nextElement) {
-	    currentElement->setNext(nextElement);
-	}
+    void setNext(LinkedElement<T>* currentElement,
+            LinkedElement<T>* nextElement) {
+        currentElement->setNext(nextElement);
+    }
 
     void setLast(LinkedElement<T>* lastElement) {
         lastElement->setEnd();
@@ -148,7 +148,7 @@ public:
     }
 
 protected:
-	LinkedElement<T> *start = nullptr;
+    LinkedElement<T> *start = nullptr;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */

container/group.h

@@ -4,9 +4,11 @@
 /**
  * @defgroup container Container
  *
- * General Purpose Containers to store various elements.
- * As opposed to the STL library implementation, these implementations
- * don't  allocate memory dynamically.
+ * General Purpose Container to store various elements.
+ *
+ * Also contains Adapter classes to print elements to a
+ * bytestream and to read them from a bytestream, as well
+ * as an Adapter to swap the endianness.
  */
 
 

container/listTest.cpp.ignore

@@ -1,365 +0,0 @@
-#include "FixedArrayList.h"
-#include "SinglyLinkedList.h"
-#include "HybridIterator.h"
-
-#include "FixedMap.h"
-
-#include <stdio.h>
-
-/*
-
-class Packet: public SinglyLinkedList {
-public:
-	SinglyLinkedList::Element<uint32_t> element1;
-	SinglyLinkedList::Element<uint32_t> element2;
-
-	Packet() {
-		this->start = &element1;
-		element1.next = &element2;
-	}
-};
-
-class Packet2: public SinglyLinkedList {
-public:
-	SinglyLinkedList::Element<uint32_t> element1;
-	SinglyLinkedList::Element<FixedArrayList<FixedArrayList<uint8_t, 5>, 2>> element2;
-	SinglyLinkedList::Element<uint32_t> element3;
-
-	Packet2() {
-		this->start = &element1;
-		element1.next = &element2;
-		element2.next = &element3;
-	}
-};
-
-class Packet3: public SinglyLinkedList {
-public:
-	SinglyLinkedList::TypedElement<uint32_t> element1;
-	SinglyLinkedList::TypedElement<uint32_t> element2;
-
-	Packet3() {
-		this->start = &element1;
-		element1.next = &element2;
-	}
-};
-
-void arrayList() {
-	puts("** Array List **");
-	FixedArrayList<uint32_t, 10, uint32_t> list;
-	FixedArrayList<uint32_t, 10, uint32_t> list2;
-
-	list.size = 2;
-
-	list[0] = 0xcafecafe;
-
-	list[1] = 0x12345678;
-
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	printf("printsize: %i\n", list.getPrintSize());
-
-	list.print(&pointer, &size, 100, true);
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	pointer = buffer;
-
-	size2 = size;
-
-	printf("list2 read: %x\n", list2.read(&pointer, &size2, true));
-
-	printf("list2(%i):", list2.size);
-	for (ArrayList<uint32_t, uint32_t>::Iterator iter = list2.begin();
-			iter != list2.end(); iter++) {
-		printf("0x%04x ", *iter);
-	}
-	printf("\n");
-
-	HybridIterator<uint32_t, uint32_t> hiter(list.begin(),list.end());
-
-	printf("hybrid1: 0x%04x\n", *(hiter++));
-	printf("hybrid2: 0x%04x\n", *hiter);
-
-}
-
-void allocatingList() {
-	puts("** Allocating List **");
-	ArrayList<uint8_t> myList(3), myList2(2);
-	myList[0] = 0xab;
-	myList[1] = 0xcd;
-	myList.size = 2;
-
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	myList.print(&pointer, &size, 100, true);
-
-	pointer = buffer;
-	size2 = size;
-
-	printf("Read %x\n", myList2.read(&pointer, &size2, true));
-
-	printf("%x,%x\n", myList2[0], myList2[1]);
-
-}
-
-void linkedList() {
-	puts("** Linked List **");
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	Packet myPacket;
-	myPacket.element1.entry = 0x12345678;
-	myPacket.element2.entry = 0x9abcdef0;
-
-	pointer = buffer;
-	size = 0;
-	ReturnValue_t result = myPacket.print(&pointer, &size, 100, true);
-
-	printf("result %02x\n", result);
-
-	printf("printsize: %i\n", myPacket.getPrintSize());
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	Packet3 myPacket3;
-
-	myPacket3.element1.entry = 0x12345678;
-	myPacket3.element2.entry = 0xabcdeff;
-
-	SinglyLinkedList::TypedIterator<uint32_t> titer(&myPacket3.element1);
-
-	printf("0x%04x\n", *titer);
-
-	HybridIterator<uint32_t, uint32_t> hiter(&myPacket3.element1);
-
-	printf("hybrid1: 0x%04x\n", *hiter);
-	hiter++;
-	printf("hybrid2: 0x%04x\n", *hiter);
-}
-
-void complex() {
-	puts("** complex **");
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2 = size;
-
-	Packet myPacket2;
-
-	size2 = size;
-	pointer = buffer;
-
-	myPacket2.read(&pointer, &size2, true);
-
-	printf("packet: 0x%04x, 0x%04x\n", myPacket2.element1.entry,
-			myPacket2.element2.entry);
-
-	buffer[0] = 0x12;
-	buffer[1] = 0x34;
-	buffer[2] = 0x56;
-	buffer[3] = 0x78;
-	buffer[4] = 0x2;
-	buffer[5] = 0x3;
-	buffer[6] = 0xab;
-	buffer[7] = 0xcd;
-	buffer[8] = 0xef;
-	buffer[9] = 0x2;
-	buffer[10] = 0x11;
-	buffer[11] = 0x22;
-	buffer[12] = 0xca;
-	buffer[13] = 0xfe;
-	buffer[14] = 0x5a;
-	buffer[15] = 0xfe;
-
-	pointer = buffer;
-	size2 = 23;
-
-	Packet2 p2;
-
-	ReturnValue_t result = p2.read(&pointer, &size2, true);
-	printf("result is %02x\n", result);
-
-	printf("%04x; %i: %i: %x %x %x; %i: %x %x;; %04x\n", p2.element1.entry,
-			p2.element2.entry.size, p2.element2.entry[0].size,
-			p2.element2.entry[0][0], p2.element2.entry[0][1],
-			p2.element2.entry[0][2], p2.element2.entry[1].size,
-			p2.element2.entry[1][0], p2.element2.entry[1][1],
-			p2.element3.entry);
-
-}
-*/
-struct Test {
-	uint32_t a;
-	uint32_t b;
-};
-
-template<typename key_t, typename T>
-void printMap(FixedMap<key_t, T> *map) {
-	typename FixedMap<key_t, T>::Iterator iter;
-	printf("Map (%i): ", map->getSize());
-	for (iter = map->begin(); iter != map->end(); ++iter) {
-		printf("%x:%08x,%08x ", iter.value->first, (*iter).a, (*iter).b);
-	}
-	printf("\n");
-}
-
-template<typename T>
-void map() {
-	puts("** Map **");
-	typename FixedMap<T, Test>::Iterator iter;
-	ReturnValue_t result;
-	FixedMap<T, Test> myMap(5);
-
-	printMap<T, Test>(&myMap);
-
-	Test a;
-	a.a = 0x01234567;
-	a.b = 0xabcdef89;
-
-	myMap.insert(1, a);
-	printMap<T, Test>(&myMap);
-
-	a.a = 0;
-
-	myMap.insert(2, a);
-	printMap<T, Test>(&myMap);
-
-	printf("2 exists: %x\n", myMap.exists(0x02));
-
-	printf("ff exists: %x\n", myMap.exists(0xff));
-
-	a.a = 1;
-	printf("insert 0x2: %x\n", myMap.insert(2, a));
-
-	result = myMap.insert(0xff, a);
-	a.a = 0x44;
-	result = myMap.insert(0xab, a);
-	result = myMap.insert(0xa, a);
-
-	printMap<T, Test>(&myMap);
-
-	printf("insert 0x5: %x\n", myMap.insert(5, a));
-
-	printf("erase 0xfe: %x\n", myMap.erase(0xfe));
-
-	printf("erase 0x2: %x\n", myMap.erase(0x2));
-
-	printMap<T, Test>(&myMap);
-
-	printf("erase 0xab: %x\n", myMap.erase(0xab));
-	printMap<T, Test>(&myMap);
-
-	printf("insert 0x5: %x\n", myMap.insert(5, a));
-	printMap<T, Test>(&myMap);
-
-	iter = myMap.begin();
-	++iter;
-	++iter;
-	++iter;
-
-	printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
-
-	myMap.erase(&iter);
-
-	printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
-	printMap<T, Test>(&myMap);
-
-}
-
-/*
-void mapPrint() {
-	puts("** Map Print **");
-	FixedMap<uint16_t, Packet2> myMap(5);
-	Packet2 myPacket;
-	myPacket.element1.entry = 0x12345678;
-
-	myPacket.element2.entry[0][0] = 0xab;
-	myPacket.element2.entry[0][1] = 0xcd;
-	myPacket.element2.entry[0].size = 2;
-	myPacket.element2.entry.size = 1;
-
-	myPacket.element3.entry = 0xabcdef90;
-
-	myMap.insert(0x1234, myPacket);
-
-	uint8_t buffer[100];
-	uint32_t size = 0, i;
-	uint8_t *pointer = buffer;
-
-	printf("printsize: %i\n", myMap.getPrintSize());
-
-	SerializeAdapter<FixedMap<uint16_t, Packet2>>::print(&myMap, &pointer,
-			&size, 100, false);
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	int32_t size2 = size;
-	pointer = buffer;
-
-	FixedMap<uint16_t, Packet2> myMap2(5);
-
-	ReturnValue_t result = SerializeAdapter<FixedMap<uint16_t, Packet2>>::read(
-			&myMap2, &pointer, &size2, false);
-
-	Packet2 *myPacket2 = myMap2.find(0x1234);
-
-	printf("Map (%i): Packet2: %x, Array (%i): Array (%i): %x, %x; %x\n",
-			myMap2.getSize(), myPacket2->element1.entry,
-			myPacket2->element2.entry.size, myPacket2->element2.entry[0].size,
-			myPacket2->element2.entry[0][0], myPacket2->element2.entry[0][1],
-			myPacket2->element3.entry);
-
-}
-
-void empty() {
-	puts("** Empty **");
-	ArrayList<uint32_t> list(0);
-	printf("%p %p\n", list.front(), list.back());
-}
-*/
-
-int main(void) {
-
-//	arrayList();
-//	linkedList();
-//	allocatingList();
-//	complex();
-
-	map<uint32_t>();
-//
-//	mapPrint();
-
-//	empty();
-
-
-
-	return 0;
-}

contrib/sgp4/sgp4unit.h

@@ -1,117 +1,117 @@
-#ifndef _sgp4unit_
-#define _sgp4unit_
-/*     ----------------------------------------------------------------
-*
-*                                 sgp4unit.h
-*
-*    this file contains the sgp4 procedures for analytical propagation
-*    of a satellite. the code was originally released in the 1980 and 1986
-*    spacetrack papers. a detailed discussion of the theory and history
-*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
-*    and kelso.
-*
-*                            companion code for
-*               fundamentals of astrodynamics and applications
-*                                    2007
-*                              by david vallado
-*
-*       (w) 719-573-2600, email dvallado@agi.com
-*
-*    current :
-*              20 apr 07  david vallado
-*                           misc fixes for constants
-*    changes :
-*              11 aug 06  david vallado
-*                           chg lyddane choice back to strn3, constants, misc doc
-*              15 dec 05  david vallado
-*                           misc fixes
-*              26 jul 05  david vallado
-*                           fixes for paper
-*                           note that each fix is preceded by a
-*                           comment with "sgp4fix" and an explanation of
-*                           what was changed
-*              10 aug 04  david vallado
-*                           2nd printing baseline working
-*              14 may 01  david vallado
-*                           2nd edition baseline
-*                     80  norad
-*                           original baseline
-*       ----------------------------------------------------------------      */
-
-#include <math.h>
-#include <stdio.h>
-
-// -------------------------- structure declarations ----------------------------
-typedef enum
-{
-  wgs72old,
-  wgs72,
-  wgs84
-} gravconsttype;
-
-typedef struct elsetrec
-{
-  long int  satnum;
-  int       epochyr, epochtynumrev;
-  int       error;
-  char      init, method;
-
-  /* Near Earth */
-  int    isimp;
-  double aycof  , con41  , cc1    , cc4      , cc5    , d2      , d3   , d4    ,
-         delmo  , eta    , argpdot, omgcof   , sinmao , t       , t2cof, t3cof ,
-         t4cof  , t5cof  , x1mth2 , x7thm1   , mdot   , nodedot, xlcof , xmcof ,
-         nodecf;
-
-  /* Deep Space */
-  int    irez;
-  double d2201  , d2211  , d3210  , d3222    , d4410  , d4422   , d5220 , d5232 ,
-         d5421  , d5433  , dedt   , del1     , del2   , del3    , didt  , dmdt  ,
-         dnodt  , domdt  , e3     , ee2      , peo    , pgho    , pho   , pinco ,
-         plo    , se2    , se3    , sgh2     , sgh3   , sgh4    , sh2   , sh3   ,
-         si2    , si3    , sl2    , sl3      , sl4    , gsto    , xfact , xgh2  ,
-         xgh3   , xgh4   , xh2    , xh3      , xi2    , xi3     , xl2   , xl3   ,
-         xl4    , xlamo  , zmol   , zmos     , atime  , xli     , xni;
-
-  double a      , altp   , alta   , epochdays, jdsatepoch       , nddot , ndot  ,
-         bstar  , rcse   , inclo  , nodeo    , ecco             , argpo , mo    ,
-         no;
-} elsetrec;
-
-// --------------------------- function declarations ----------------------------
-int sgp4init
-       (
-         gravconsttype whichconst,      const int satn,     const double epoch,
-         const double xbstar, const double xecco, const double xargpo,
-         const double xinclo, const double xmo,   const double xno,
-         const double xnodeo,
-         elsetrec& satrec
-       );
-
-int sgp4
-       (
-         gravconsttype whichconst,
-         elsetrec& satrec, double tsince,
-         double r[], double v[]
-       );
-
-double  gstime
-       (
-         double
-       );
-
-void getgravconst
-      (
-       gravconsttype,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&
-      );
-
-#endif
-
+#ifndef _sgp4unit_
+#define _sgp4unit_
+/*     ----------------------------------------------------------------
+*
+*                                 sgp4unit.h
+*
+*    this file contains the sgp4 procedures for analytical propagation
+*    of a satellite. the code was originally released in the 1980 and 1986
+*    spacetrack papers. a detailed discussion of the theory and history
+*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
+*    and kelso.
+*
+*                            companion code for
+*               fundamentals of astrodynamics and applications
+*                                    2007
+*                              by david vallado
+*
+*       (w) 719-573-2600, email dvallado@agi.com
+*
+*    current :
+*              20 apr 07  david vallado
+*                           misc fixes for constants
+*    changes :
+*              11 aug 06  david vallado
+*                           chg lyddane choice back to strn3, constants, misc doc
+*              15 dec 05  david vallado
+*                           misc fixes
+*              26 jul 05  david vallado
+*                           fixes for paper
+*                           note that each fix is preceded by a
+*                           comment with "sgp4fix" and an explanation of
+*                           what was changed
+*              10 aug 04  david vallado
+*                           2nd printing baseline working
+*              14 may 01  david vallado
+*                           2nd edition baseline
+*                     80  norad
+*                           original baseline
+*       ----------------------------------------------------------------      */
+
+#include <math.h>
+#include <stdio.h>
+
+// -------------------------- structure declarations ----------------------------
+typedef enum
+{
+  wgs72old,
+  wgs72,
+  wgs84
+} gravconsttype;
+
+typedef struct elsetrec
+{
+  long int  satnum;
+  int       epochyr, epochtynumrev;
+  int       error;
+  char      init, method;
+
+  /* Near Earth */
+  int    isimp;
+  double aycof  , con41  , cc1    , cc4      , cc5    , d2      , d3   , d4    ,
+         delmo  , eta    , argpdot, omgcof   , sinmao , t       , t2cof, t3cof ,
+         t4cof  , t5cof  , x1mth2 , x7thm1   , mdot   , nodedot, xlcof , xmcof ,
+         nodecf;
+
+  /* Deep Space */
+  int    irez;
+  double d2201  , d2211  , d3210  , d3222    , d4410  , d4422   , d5220 , d5232 ,
+         d5421  , d5433  , dedt   , del1     , del2   , del3    , didt  , dmdt  ,
+         dnodt  , domdt  , e3     , ee2      , peo    , pgho    , pho   , pinco ,
+         plo    , se2    , se3    , sgh2     , sgh3   , sgh4    , sh2   , sh3   ,
+         si2    , si3    , sl2    , sl3      , sl4    , gsto    , xfact , xgh2  ,
+         xgh3   , xgh4   , xh2    , xh3      , xi2    , xi3     , xl2   , xl3   ,
+         xl4    , xlamo  , zmol   , zmos     , atime  , xli     , xni;
+
+  double a      , altp   , alta   , epochdays, jdsatepoch       , nddot , ndot  ,
+         bstar  , rcse   , inclo  , nodeo    , ecco             , argpo , mo    ,
+         no;
+} elsetrec;
+
+// --------------------------- function declarations ----------------------------
+int sgp4init
+       (
+         gravconsttype whichconst,      const int satn,     const double epoch,
+         const double xbstar, const double xecco, const double xargpo,
+         const double xinclo, const double xmo,   const double xno,
+         const double xnodeo,
+         elsetrec& satrec
+       );
+
+int sgp4
+       (
+         gravconsttype whichconst,
+         elsetrec& satrec, double tsince,
+         double r[], double v[]
+       );
+
+double  gstime
+       (
+         double
+       );
+
+void getgravconst
+      (
+       gravconsttype,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&
+      );
+
+#endif
+

controller/CMakeLists.txt

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

controller/ControllerBase.cpp

@@ -1,137 +1,137 @@
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/controller/ControllerBase.h>
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/action/HasActionsIF.h>
+#include "ControllerBase.h"
 
-ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId,
-		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF), submode(
-				SUBMODE_NONE), commandQueue(NULL), modeHelper(
-				this), healthHelper(this, setObjectId),hkSwitcher(this),executingTask(NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../action/HasActionsIF.h"
 
+ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
+        size_t commandQueueDepth) :
+        SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+        submode(SUBMODE_NONE), modeHelper(this),
+        healthHelper(this, setObjectId) {
+    commandQueue = QueueFactory::instance()->createMessageQueue(
+            commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+    QueueFactory::instance()->deleteMessageQueue(commandQueue);
 }
 
 ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != 0) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
+    MessageQueueId_t parentQueue = 0;
+    if (parentId != objects::NO_OBJECT) {
+        SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+        if (parent == nullptr) {
+            return RETURN_FAILED;
+        }
+        parentQueue = parent->getCommandQueue();
 
-		parent->registerChild(getObjectId());
-	}
+        parent->registerChild(getObjectId());
+    }
 
-	result = healthHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
+    result = healthHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	result = modeHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
+    result = modeHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	result = hkSwitcher.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
+    return commandQueue->getId();
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
 
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
 
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		result = handleCommandMessage(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
 
 }
 
 void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
-	changeHK(this->mode, this->submode, false);
-	triggerEvent(CHANGING_MODE, mode, submode);
-	this->mode = mode;
-	this->submode = submode;
-	modeHelper.modeChanged(mode, submode);
-	modeChanged(mode, submode);
-	announceMode(false);
-	changeHK(this->mode, this->submode, true);
+    changeHK(this->mode, this->submode, false);
+    triggerEvent(CHANGING_MODE, mode, submode);
+    this->mode = mode;
+    this->submode = submode;
+    modeHelper.modeChanged(mode, submode);
+    modeChanged(mode, submode);
+    announceMode(false);
+    changeHK(this->mode, this->submode, true);
 }
 
 void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
+    *mode = this->mode;
+    *submode = this->submode;
 }
 
 void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
+    healthHelper.setHealth(EXTERNAL_CONTROL);
 }
 
 void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
+    triggerEvent(MODE_INFO, mode, submode);
 }
 
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	hkSwitcher.performOperation();
-	performControlOperation();
-	return RETURN_OK;
+    handleQueue();
+    performControlOperation();
+    return RETURN_OK;
 }
 
 void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	return;
+    return;
 }
 
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
+    switch (health) {
+    case HEALTHY:
+    case EXTERNAL_CONTROL:
+        healthHelper.setHealth(health);
+        return RETURN_OK;
+    default:
+        return INVALID_HEALTH_STATE;
+    }
 }
 
 HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
+    return healthHelper.getHealth();
 }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
+            executingTask = task_;
 }
 
 void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}

controller/ControllerBase.h

@@ -1,79 +1,94 @@
-#ifndef CONTROLLERBASE_H_
-#define CONTROLLERBASE_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/modes/ModeHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/datapool/HkSwitchHelper.h>
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
 
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+#include "../datapool/HkSwitchHelper.h"
 
+/**
+ * @brief   Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers, which generally have
+ * a mode and a health state. This avoids boilerplate code.
+ */
 class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
+        public HasHealthIF,
+        public ExecutableObjectIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
 public:
+    static const Mode_t MODE_NORMAL = 2;
 
-	static const Mode_t MODE_NORMAL = 2;
+    ControllerBase(object_id_t setObjectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ControllerBase();
 
-	ControllerBase(uint32_t setObjectId, uint32_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
+    /** SystemObject override */
+    virtual ReturnValue_t initialize() override;
 
-	ReturnValue_t initialize();
+    virtual MessageQueueId_t getCommandQueue() const override;
 
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_);
+    /** HasHealthIF overrides */
+    virtual ReturnValue_t setHealth(HealthState health) override;
+    virtual HasHealthIF::HealthState getHealth() override;
 
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual void setTaskIF(PeriodicTaskIF* task) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
-	const uint32_t parentId;
 
-	Mode_t mode;
+    /**
+     * Implemented by child class. Handle command messages which are not
+     * mode or health messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
 
-	Submode_t submode;
+    /**
+     * Periodic helper, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
 
-	MessageQueueIF* commandQueue;
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) = 0;
 
-	ModeHelper modeHelper;
+    const object_id_t parentId;
 
-	HealthHelper healthHelper;
+    Mode_t mode;
 
-	HkSwitchHelper hkSwitcher;
+    Submode_t submode;
 
-	/**
-	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask;
+    MessageQueueIF* commandQueue = nullptr;
 
-	void handleQueue();
+    ModeHelper modeHelper;
 
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-	virtual void performControlOperation() = 0;
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
-	virtual void modeChanged(Mode_t mode, Submode_t submode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+    HealthHelper healthHelper;
+
+    /**
+     * Pointer to the task which executes this component,
+     * is invalid before setTaskIF was called.
+     */
+    PeriodicTaskIF* executingTask = nullptr;
+
+    /** Handle mode and health messages */
+    virtual void handleQueue();
+
+    /** Mode helpers */
+    virtual void modeChanged(Mode_t mode, Submode_t submode);
+    virtual void startTransition(Mode_t mode, Submode_t submode);
+    virtual void getMode(Mode_t *mode, Submode_t *submode);
+    virtual void setToExternalControl();
+    virtual void announceMode(bool recursive);
+    /** HK helpers */
+    virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
-#endif /* CONTROLLERBASE_H_ */
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

controller/ExtendedControllerBase.cpp

@@ -0,0 +1,104 @@
+#include "ExtendedControllerBase.h"
+
+
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
+        object_id_t parentId, size_t commandQueueDepth):
+        ControllerBase(objectId, parentId, commandQueueDepth),
+        poolManager(this, commandQueue),
+        actionHelper(this, commandQueue) {
+}
+
+ExtendedControllerBase::~ExtendedControllerBase() {
+}
+
+ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
+        MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
+    /* Needs to be overriden and implemented by child class. */
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t ExtendedControllerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+ReturnValue_t ExtendedControllerBase::handleCommandMessage(
+        CommandMessage *message) {
+    ReturnValue_t result = actionHelper.handleActionMessage(message);
+    if(result == HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return poolManager.handleHousekeepingMessage(message);
+}
+
+void ExtendedControllerBase::handleQueue() {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
+        result = actionHelper.handleActionMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = poolManager.handleHousekeepingMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
+}
+
+ReturnValue_t ExtendedControllerBase::initialize() {
+    ReturnValue_t result = ControllerBase::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = actionHelper.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    return poolManager.initialize(commandQueue);
+}
+
+ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
+    return poolManager.initializeAfterTaskCreation();
+}
+
+ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
+    handleQueue();
+    performControlOperation();
+    /* We do this after performing control operation because variables will be set changed
+    in this function. */
+    poolManager.performHkOperation();
+    return RETURN_OK;
+}
+
+MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
+    return commandQueue->getId();
+}
+
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &poolManager;
+}

controller/ExtendedControllerBase.h

@@ -0,0 +1,73 @@
+#ifndef FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+#define FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+
+#include "ControllerBase.h"
+
+#include "../action/HasActionsIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../action/ActionHelper.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+
+/**
+ * @brief   Extendes the basic ControllerBase with the common components
+ *          HasActionsIF for commandability and HasLocalDataPoolIF to keep
+ *          a pool of local data pool variables.
+ * @details
+ * Default implementations required for the interfaces will be empty and have
+ * to be implemented by child class.
+ */
+class ExtendedControllerBase: public ControllerBase,
+        public HasActionsIF,
+        public HasLocalDataPoolIF {
+public:
+    ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ExtendedControllerBase();
+
+    /* SystemObjectIF overrides */
+    virtual ReturnValue_t initialize() override;
+
+    virtual MessageQueueId_t getCommandQueue() const override;
+
+    /* ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+    LocalDataPoolManager poolManager;
+    ActionHelper actionHelper;
+
+    /**
+     * Implemented by child class. Handle all command messages which are
+     * not health, mode, action or housekeeping messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper from ControllerBase, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    /* Handle the four messages mentioned above */
+    void handleQueue() override;
+
+    /* HasActionsIF overrides */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data,
+            size_t size) override;
+
+    /* HasLocalDatapoolIF overrides */
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual object_id_t getObjectId() const override;
+    virtual uint32_t getPeriodicOperationFrequency() const override;
+
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override = 0;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+};
+
+
+
+#endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

coordinates/CMakeLists.txt

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

coordinates/CoordinateTransformations.cpp

@@ -1,7 +1,7 @@
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/globalfunctions/constants.h>
-#include <framework/globalfunctions/math/MatrixOperations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
 #include <stddef.h>
 #include <cmath>
 

coordinates/CoordinateTransformations.h

@@ -1,7 +1,7 @@
 #ifndef COORDINATETRANSFORMATIONS_H_
 #define COORDINATETRANSFORMATIONS_H_
 
-#include <framework/timemanager/Clock.h>
+#include "../timemanager/Clock.h"
 #include <cstring>
 
 class CoordinateTransformations {

coordinates/Jgm3Model.h

@@ -2,10 +2,10 @@
 #define FRAMEWORK_COORDINATES_JGM3MODEL_H_
 
 #include <stdint.h>
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
-#include <framework/globalfunctions/timevalOperations.h>
-#include <framework/globalfunctions/constants.h>
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include "../globalfunctions/constants.h"
 #include <memory.h>
 
 

coordinates/Sgp4Propagator.cpp

@@ -1,9 +1,9 @@
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/coordinates/Sgp4Propagator.h>
-#include <framework/globalfunctions/constants.h>
-#include <framework/globalfunctions/math/MatrixOperations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
-#include <framework/globalfunctions/timevalOperations.h>
+#include "CoordinateTransformations.h"
+#include "Sgp4Propagator.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
 #include <cstring>
 Sgp4Propagator::Sgp4Propagator() :
 		initialized(false), epoch({0, 0}), whichconst(wgs84) {

coordinates/Sgp4Propagator.h

@@ -1,9 +1,11 @@
 #ifndef SGP4PROPAGATOR_H_
 #define SGP4PROPAGATOR_H_
 
+#ifndef WIN32
 #include <sys/time.h>
+#endif
 #include "../contrib/sgp4/sgp4unit.h"
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
 
 class Sgp4Propagator {
 public:

datalinklayer/BCFrame.h

@@ -8,7 +8,7 @@
 #ifndef BCFRAME_H_
 #define BCFRAME_H_
 
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
+#include "CCSDSReturnValuesIF.h"
 
 /**
  * Small helper class to identify a BcFrame.

datalinklayer/CCSDSReturnValuesIF.h

@@ -8,7 +8,7 @@
 #ifndef CCSDSRETURNVALUESIF_H_
 #define CCSDSRETURNVALUESIF_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
 /**
  * This is a helper class to collect special return values that come up during CCSDS Handling.
  * @ingroup ccsds_handling

datalinklayer/CMakeLists.txt

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

datalinklayer/Clcw.cpp

@@ -7,8 +7,8 @@
 
 
 
-#include <framework/datalinklayer/Clcw.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "Clcw.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Clcw::Clcw() {
 	content.raw = 0;
@@ -55,7 +55,9 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+#endif
 }
 
 void Clcw::setWhole(uint32_t rawClcw) {

datalinklayer/Clcw.h

@@ -8,7 +8,7 @@
 #ifndef CLCW_H_
 #define CLCW_H_
 
-#include <framework/datalinklayer/ClcwIF.h>
+#include "ClcwIF.h"
 /**
  * Small helper method to handle the Clcw values.
  * It has a content struct that manages the register and can be set externally.

datalinklayer/DataLinkLayer.cpp

@@ -1,6 +1,6 @@
-#include <framework/datalinklayer/DataLinkLayer.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "DataLinkLayer.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
 		uint8_t set_start_sequence_length, uint16_t set_scid) :
@@ -98,8 +98,10 @@ ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
 	receivedDataLength = length;
 	ReturnValue_t status = allFramesReception();
 	if (status != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
 		         "Error code: " << std::hex << status << std::dec << std::endl;
+#endif
 //		currentFrame.print();
 		return status;
 	} else {
@@ -124,7 +126,9 @@ ReturnValue_t DataLinkLayer::initialize() {
 	if ( virtualChannels.begin() != virtualChannels.end() ) {
 		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
 	} else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 

datalinklayer/DataLinkLayer.h

@@ -1,11 +1,11 @@
 #ifndef DATALINKLAYER_H_
 #define DATALINKLAYER_H_
 
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReceptionIF.h>
-#include <framework/events/Event.h>
+#include "CCSDSReturnValuesIF.h"
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReceptionIF.h"
+#include "../events/Event.h"
 #include <map>
 
 
@@ -19,12 +19,12 @@ class VirtualChannelReception;
 class DataLinkLayer : public CCSDSReturnValuesIF {
 public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
-	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
-	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
-	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
-	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
-//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
-	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
+	static const Event RF_AVAILABLE = MAKE_EVENT(0, severity::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
+	static const Event RF_LOST = MAKE_EVENT(1, severity::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
+	static const Event BIT_LOCK = MAKE_EVENT(2, severity::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, severity::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
+//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, severity::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
+	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, severity::LOW); //!< The CCSDS Board could not interpret a TC
 	/**
 	 * The Constructor sets the passed parameters and nothing else.
 	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.

datalinklayer/Farm1StateIF.h

@@ -8,7 +8,7 @@
 #ifndef FARM1STATEIF_H_
 #define FARM1STATEIF_H_
 
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
+#include "CCSDSReturnValuesIF.h"
 class VirtualChannelReception;
 class TcTransferFrame;
 class ClcwIF;

datalinklayer/Farm1StateLockout.cpp

@@ -7,10 +7,10 @@
 
 
 
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateLockout.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
+#include "ClcwIF.h"
+#include "Farm1StateLockout.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
 Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
 }
 

datalinklayer/Farm1StateLockout.h

@@ -8,7 +8,7 @@
 #ifndef FARM1STATELOCKOUT_H_
 #define FARM1STATELOCKOUT_H_
 
-#include <framework/datalinklayer/Farm1StateIF.h>
+#include "Farm1StateIF.h"
 
 /**
  * This class represents the FARM-1 "Lockout" State.

datalinklayer/Farm1StateOpen.cpp

@@ -8,10 +8,10 @@
 
 
 
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateOpen.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
+#include "ClcwIF.h"
+#include "Farm1StateOpen.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
 
 Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
 }

datalinklayer/Farm1StateOpen.h

@@ -8,7 +8,7 @@
 #ifndef FARM1STATEOPEN_H_
 #define FARM1STATEOPEN_H_
 
-#include <framework/datalinklayer/Farm1StateIF.h>
+#include "Farm1StateIF.h"
 
 /**
  * This class represents the FARM-1 "Open" State.

datalinklayer/Farm1StateWait.cpp

@@ -6,10 +6,10 @@
  */
 
 
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateWait.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
+#include "ClcwIF.h"
+#include "Farm1StateWait.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
 
 Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
 }

datalinklayer/Farm1StateWait.h

@@ -8,7 +8,7 @@
 #ifndef FARM1STATEWAIT_H_
 #define FARM1STATEWAIT_H_
 
-#include <framework/datalinklayer/Farm1StateIF.h>
+#include "Farm1StateIF.h"
 
 /**
  * This class represents the FARM-1 "Wait" State.

datalinklayer/MapPacketExtraction.cpp

@@ -1,25 +1,18 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include <framework/datalinklayer/MapPacketExtraction.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <string.h>
+#include "MapPacketExtraction.h"
+#include "../ipc/QueueFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include <cstring>
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId),
 		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
+		tcQueueId(MessageQueueIF::NO_QUEUE) {
+	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
 ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
@@ -36,9 +29,11 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 			bufferPosition = &packetBuffer[packetLength];
 			status = RETURN_OK;
 		} else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 					<< packetLength << std::endl;
+#endif
 			clearBuffers();
 			status = CONTENT_TOO_LARGE;
 		}
@@ -58,24 +53,30 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				}
 				status = RETURN_OK;
 			} else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error
 						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 						<< packetLength << std::endl;
+#endif
 				clearBuffers();
 				status = CONTENT_TOO_LARGE;
 			}
 		} else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
 					<< (int) lastSegmentationFlag << std::endl;
+#endif
 			clearBuffers();
 			status = ILLEGAL_SEGMENTATION_FLAG;
 		}
 		break;
 	default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error
 				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
 				<< (int) segmentationFlag << std::endl;
+#endif
 		clearBuffers();
 		status = DATA_CORRUPTED;
 		break;
@@ -142,10 +143,14 @@ ReturnValue_t MapPacketExtraction::initialize() {
 }
 
 void MapPacketExtraction::printPacketBuffer(void) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+#endif
 	for (uint32_t i = 0; i < this->packetLength; ++i) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
 				<< (uint16_t) this->packetBuffer[i] << std::endl;
+#endif
 	}
 }
 

datalinklayer/MapPacketExtraction.h

@@ -1,17 +1,10 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
+#ifndef FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+#define FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
 
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
-
-#include <framework/datalinklayer/MapPacketExtractionIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
+#include "MapPacketExtractionIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
 
 class StorageManagerIF;
 
@@ -20,17 +13,19 @@ class StorageManagerIF;
  * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
  * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
  * fully received. All found packets are forwarded to a single distribution entity.
+ * @author B. Baetz
  */
 class MapPacketExtraction: public MapPacketExtractionIF {
 private:
 	static const uint32_t MAX_PACKET_SIZE = 4096;
 	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
 	uint8_t mapId;	//!< MAP ID of this MAP Channel.
-	uint32_t packetLength;	//!< Complete length of the current Space Packet.
+	uint32_t packetLength = 0;	//!< Complete length of the current Space Packet.
 	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
 	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
 	object_id_t packetDestination;
-	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
+	//!< Pointer to the store where full TC packets are stored.
+	StorageManagerIF* packetStore = nullptr;
 	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
 	/**
 	 * Debug method to print the packet Buffer's content.
@@ -75,4 +70,4 @@ public:
 	uint8_t getMapId() const;
 };
 
-#endif /* MAPPACKETEXTRACTION_H_ */
+#endif /* FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_ */

datalinklayer/MapPacketExtractionIF.h

@@ -8,8 +8,8 @@
 #ifndef MAPPACKETEXTRACTIONIF_H_
 #define MAPPACKETEXTRACTIONIF_H_
 
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
+#include "CCSDSReturnValuesIF.h"
+#include "TcTransferFrame.h"
 
 /**
  * This is the interface for MAP Packet Extraction classes.

datalinklayer/TcTransferFrame.cpp

@@ -7,8 +7,8 @@
 
 
 
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "TcTransferFrame.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 TcTransferFrame::TcTransferFrame() {
 	 frame = NULL;
@@ -87,16 +87,25 @@ uint8_t* TcTransferFrame::getFullDataField() {
 }
 
 void TcTransferFrame::print() {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Raw Frame: " << std::hex << std::endl;
 	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
 		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
 	}
 	sif::debug << std::dec << std::endl;
-//	debug << "Frame Header:" << std::endl;
-//	debug << "Version Number: " << std::hex << (uint16_t)this->current_frame.getVersionNumber() << std::endl;
-//	debug << "Bypass Flag set?| Ctrl Cmd Flag set?: " << (uint16_t)this->current_frame.bypassFlagSet() << " | " << (uint16_t)this->current_frame.controlCommandFlagSet()  << std::endl;
-//	debug << "SCID : " << this->current_frame.getSpacecraftId() << std::endl;
-//	debug << "VCID : " << (uint16_t)this->current_frame.getVirtualChannelId() << std::endl;
-//	debug << "Frame length: " << std::dec << this->current_frame.getFrameLength() << std::endl;
-//	debug << "Sequence Number: " << (uint16_t)this->current_frame.getSequenceNumber() << std::endl;
+
+	sif::debug << "Frame Header:" << std::endl;
+	sif::debug << "Version Number: " << std::hex
+			<< (uint16_t)this->getVersionNumber() << std::endl;
+	sif::debug << "Bypass Flag set?| Ctrl Cmd Flag set?: "
+			<< (uint16_t)this->bypassFlagSet() << " | "
+			<< (uint16_t)this->controlCommandFlagSet()  << std::endl;
+	sif::debug << "SCID : " << this->getSpacecraftId() << std::endl;
+	sif::debug << "VCID : " << (uint16_t)this->getVirtualChannelId()
+			<< std::endl;
+	sif::debug << "Frame length: " << std::dec << this->getFrameLength()
+			<< std::endl;
+	sif::debug << "Sequence Number: " << (uint16_t)this->getSequenceNumber()
+			<< std::endl;
+#endif
 }

datalinklayer/TcTransferFrameLocal.cpp

@@ -5,9 +5,9 @@
  * @author	baetz
  */
 
-#include <framework/datalinklayer/TcTransferFrameLocal.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "TcTransferFrameLocal.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include <string.h>
 
 TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
@@ -37,7 +37,9 @@ TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uin
 			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
 			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
 		} else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+#endif
 		}
 	} else {
 		//No data in frame

datalinklayer/TcTransferFrameLocal.h

@@ -8,7 +8,7 @@
 #ifndef TCTRANSFERFRAMELOCAL_H_
 #define TCTRANSFERFRAMELOCAL_H_
 
-#include <framework/datalinklayer/TcTransferFrame.h>
+#include "TcTransferFrame.h"
 
 /**
  * This is a helper class to locally create TC Transfer Frames.

datalinklayer/VirtualChannelReception.cpp

@@ -5,9 +5,9 @@
  * @author	baetz
  */
 
-#include <framework/datalinklayer/BCFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "BCFrame.h"
+#include "VirtualChannelReception.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
 		uint8_t setSlidingWindowWidth) :
@@ -102,8 +102,10 @@ uint8_t VirtualChannelReception::getChannelId() const {
 ReturnValue_t VirtualChannelReception::initialize() {
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
 				<< (int) slidingWindowWidth << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();

datalinklayer/VirtualChannelReception.h

@@ -8,14 +8,14 @@
 #ifndef VIRTUALCHANNELRECEPTION_H_
 #define VIRTUALCHANNELRECEPTION_H_
 
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/Clcw.h>
-#include <framework/datalinklayer/Farm1StateIF.h>
-#include <framework/datalinklayer/Farm1StateLockout.h>
-#include <framework/datalinklayer/Farm1StateOpen.h>
-#include <framework/datalinklayer/Farm1StateWait.h>
-#include <framework/datalinklayer/MapPacketExtractionIF.h>
-#include <framework/datalinklayer/VirtualChannelReceptionIF.h>
+#include "CCSDSReturnValuesIF.h"
+#include "Clcw.h"
+#include "Farm1StateIF.h"
+#include "Farm1StateLockout.h"
+#include "Farm1StateOpen.h"
+#include "Farm1StateWait.h"
+#include "MapPacketExtractionIF.h"
+#include "VirtualChannelReceptionIF.h"
 #include <map>
 /**
  * Implementation of a TC Virtual Channel.

datalinklayer/VirtualChannelReceptionIF.h

@@ -8,9 +8,9 @@
 #ifndef VIRTUALCHANNELRECEPTIONIF_H_
 #define VIRTUALCHANNELRECEPTIONIF_H_
 
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
 /**
  * This is the interface for Virtual Channel reception classes.

datapool/CMakeLists.txt

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

datapool/ControllerSet.cpp

@@ -1,14 +0,0 @@
-#include <framework/datapool/ControllerSet.h>
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}

datapool/ControllerSet.h

@@ -1,15 +0,0 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /* CONTROLLERSET_H_ */

datapool/DataSetBase.cpp

@@ -1,168 +0,0 @@
-#include <framework/datapool/DataSetBase.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
-        const size_t maxFillCount):
-        registeredVariables(registeredVariablesArray),
-        maxFillCount(maxFillCount) {
-	for (uint8_t count = 0; count < maxFillCount; count++) {
-		registeredVariables[count] = nullptr;
-	}
-}
-
-DataSetBase::~DataSetBase() {}
-
-ReturnValue_t DataSetBase::registerVariable(
-		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
-		sif::error << "DataSet::registerVariable: "
-				"Call made in wrong position." << std::endl;
-		return DataSetIF::DATA_SET_UNINITIALISED;
-	}
-	if (variable == nullptr) {
-		sif::error << "DataSet::registerVariable: "
-				"Pool variable is nullptr." << std::endl;
-		return DataSetIF::POOL_VAR_NULL;
-	}
-	if (fillCount >= maxFillCount) {
-		sif::error << "DataSet::registerVariable: "
-				"DataSet is full." << std::endl;
-		return DataSetIF::DATA_SET_FULL;
-	}
-	registeredVariables[fillCount] = variable;
-	fillCount++;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
-		lockDataPool(lockTimeout);
-		for (uint16_t count = 0; count < fillCount; count++) {
-			result = readVariable(count);
-			if(result != RETURN_OK) {
-				break;
-			}
-		}
-		state = States::DATA_SET_WAS_READ;
-		unlockDataPool();
-	}
-	else {
-		sif::error << "DataSet::read(): "
-				"Call made in wrong position. Don't forget to commit"
-				" member datasets!" << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
-
-uint16_t DataSetBase::getFillCount() const {
-    return fillCount;
-}
-
-ReturnValue_t DataSetBase::readVariable(uint16_t count) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	// These checks are often performed by the respective
-	// variable implementation too, but I guess a double check does not hurt.
-	if (registeredVariables[count]->getReadWriteMode() !=
-				PoolVariableIF::VAR_WRITE and
-		registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER)
-	{
-		result = registeredVariables[count]->readWithoutLock();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			result = INVALID_PARAMETER_DEFINITION;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(lockTimeout);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return handleUnreadDatasetCommit(lockTimeout);
-	}
-}
-
-void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
-	lockDataPool(lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
-		}
-	}
-	state = States::DATA_SET_UNINITIALISED;
-	unlockDataPool();
-}
-
-ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				== PoolVariableIF::VAR_WRITE
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
-		} else if (registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if (result != COMMITING_WITHOUT_READING) {
-				sif::error << "DataSet::commit(): commit-without-read call made "
-						"with non write-only variable." << std::endl;
-				result = COMMITING_WITHOUT_READING;
-			}
-		}
-	}
-	state = States::DATA_SET_UNINITIALISED;
-	unlockDataPool();
-	return result;
-}
-
-
-ReturnValue_t DataSetBase::lockDataPool(uint32_t timeoutMs) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::unlockDataPool() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
-        SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t DataSetBase::getSerializedSize() const {
-	uint32_t size = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}

datapool/DataSetBase.h

@@ -1,149 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/ipc/MutexIF.h>
-
-/**
- * @brief	The DataSetBase class manages a set of locally checked out variables.
- * @details
- * This class manages a list, where a set of local variables (or pool variables)
- * are registered. They are checked-out (i.e. their values are looked
- * up and copied) with the read call. After the user finishes working with the
- * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the data pool,
- * to ensure that all values are read and written back at once.
- *
- * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
- * after the read call.
- *
- * If pool variables are writable and not committed until destruction
- * of the set, the DataSet class automatically sets the valid flag in the
- * data pool to invalid (without) changing the variable's value.
- *
- * The base class lockDataPool und unlockDataPool implementation are empty
- * and should be implemented to protect the underlying pool type.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class DataSetBase: public DataSetIF,
-		public SerializeIF,
-		public HasReturnvaluesIF {
-public:
-
-	/**
-	 * @brief	Creates an empty dataset. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	DataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxFillCount);
-	virtual~ DataSetBase();
-
-	/**
-	 * @brief	The read call initializes reading out all registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls all read()
-	 * functions of the registered pool variables (which read out their values
-	 * from the data pool) which are not write-only.
-	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
-	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
-	 *
-	 * The data pool is locked during the whole read operation and
-	 * freed afterwards.The state changes to "was written" after this operation.
-	 * @return
-	 * - @c RETURN_OK if all variables were read successfully.
-	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * requested variable is invalid.
-	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * commit() in between
-	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call initializes writing back the registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls the
-	 * commit() method of the remaining registered variables (which write back
-	 * their values to the pool).
-	 *
-	 * The data pool is locked during the whole commit operation and
-	 * freed afterwards. The state changes to "was committed" after this operation.
-	 *
-	 * If the set does contain at least one variable which is not write-only
-	 * commit() can only be called after read(). If the set only contains
-	 * variables which are write only, commit() can be called without a
-	 * preceding read() call.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			  contains non write-only variables
-	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
-
-	/**
-	 * Register the passed pool variable instance into the data set.
-	 * @param variable
-	 * @return
-	 */
-	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
-	/**
-	 * Provides the means to lock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
-			MutexIF::BLOCKING) override;
-	/**
-	 * Provides the means to unlock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t unlockDataPool() override;
-
-	virtual uint16_t getFillCount() const;
-
-	/* SerializeIF implementations */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize,
-				SerializeIF::Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-protected:
-	/**
-	 * @brief	The fill_count attribute ensures that the variables
-	 * 			register in the correct array position and that the maximum
-	 * 			number of variables is not exceeded.
-	 */
-	uint16_t fillCount = 0;
-	/**
-	 * States of the seet.
-	 */
-	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * @brief	state manages the internal state of the data set,
-	 *          which is important e.g. for the behavior on destruction.
-	 */
-	States state = States::DATA_SET_UNINITIALISED;
-
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 * Child classes can use a static or dynamic container to create
-	 * an array of registered variables and assign the first entry here.
-	 */
-	PoolVariableIF** registeredVariables = nullptr;
-	const size_t maxFillCount = 0;
-
-private:
-	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
-	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
-};
-
-#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */

datapool/DataSetIF.h

@@ -1,8 +1,8 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
+#ifndef FSFW_DATAPOOL_DATASETIF_H_
+#define FSFW_DATAPOOL_DATASETIF_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Clock.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Clock.h"
 class PoolVariableIF;
 
 /**
@@ -18,15 +18,13 @@ class PoolVariableIF;
 class DataSetIF {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION = MAKE_RETURN_CODE(1);
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING = MAKE_RETURN_CODE(3);
 
-	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE( 0x04 );
-	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
-	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE(4);
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE(5);
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE(6);
 
 	/**
 	 * @brief	This is an empty virtual destructor,
@@ -34,8 +32,6 @@ public:
 	 */
 	virtual ~DataSetIF() {}
 
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
 	/**
 	 * @brief	This operation provides a method to register local data pool
 	 * 			variables to register in a data set by passing itself
@@ -44,19 +40,6 @@ public:
 	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
 
 	virtual uint16_t getFillCount() const = 0;
-private:
-	/**
-	 * @brief 	Most underlying data structures will have a pool like structure
-	 * 			and will require a lock and unlock mechanism to ensure
-	 * 			thread-safety
-	 * @return Lock operation result
-	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs) = 0;
-	/**
-	 * @brief   Unlock call corresponding to the lock call.
-	 * @return Unlock operation result
-	 */
-	virtual ReturnValue_t unlockDataPool() = 0;
 };
 
-#endif /* DATASETIF_H_ */
+#endif /* FSFW_DATAPOOL_DATASETIF_H_ */

datapool/HkSwitchHelper.cpp

@@ -1,5 +1,5 @@
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/ipc/QueueFactory.h>
+#include "../datapool/HkSwitchHelper.h"
+#include "../ipc/QueueFactory.h"
 
 HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
 		commandActionHelper(this), eventProxy(eventProxy) {
@@ -7,7 +7,7 @@ HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
 }
 
 HkSwitchHelper::~HkSwitchHelper() {
-	// TODO Auto-generated destructor stub
+    QueueFactory::instance()->deleteMessageQueue(actionQueue);
 }
 
 ReturnValue_t HkSwitchHelper::initialize() {

datapool/HkSwitchHelper.h

@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
 #define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
 
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/action/CommandsActionsIF.h>
-#include <framework/events/EventReportingProxyIF.h>
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/CommandsActionsIF.h"
+#include "../events/EventReportingProxyIF.h"
 
 //TODO this class violations separation between mission and framework
 //but it is only a transitional solution until the Datapool is
@@ -13,7 +13,7 @@ class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
+	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, severity::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
 
 	HkSwitchHelper(EventReportingProxyIF *eventProxy);
 	virtual ~HkSwitchHelper();

datapool/PoolDataSetBase.cpp

@@ -0,0 +1,233 @@
+#include "PoolDataSetBase.h"
+#include "ReadCommitIFAttorney.h"
+
+#include "../serviceinterface/ServiceInterface.h"
+
+#include <cstring>
+
+PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+        const size_t maxFillCount):
+        registeredVariables(registeredVariablesArray),
+        maxFillCount(maxFillCount) {}
+
+PoolDataSetBase::~PoolDataSetBase() {}
+
+
+ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF *variable) {
+    if(registeredVariables == nullptr) {
+        /* Underlying container invalid */
+        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
+        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
+        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
+        return DataSetIF::DATA_SET_FULL;
+    }
+    registeredVariables[fillCount] = variable;
+    fillCount++;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
+        uint32_t lockTimeout) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t error = result;
+    if (state == States::STATE_SET_UNINITIALISED) {
+        lockDataPool(timeoutType, lockTimeout);
+        for (uint16_t count = 0; count < fillCount; count++) {
+            result = readVariable(count);
+            if(result != RETURN_OK) {
+                error = result;
+            }
+        }
+        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 */
+        result = SET_WAS_ALREADY_READ;
+    }
+
+    if(error != HasReturnvaluesIF::RETURN_OK) {
+        result = error;
+    }
+    return result;
+}
+
+uint16_t PoolDataSetBase::getFillCount() const {
+    return fillCount;
+}
+
+ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    if(registeredVariables[count] == nullptr) {
+        /* Configuration error. */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    /* These checks are often performed by the respective variable implementation too, but I guess
+    a double check does not hurt. */
+    if (registeredVariables[count]->getReadWriteMode() != PoolVariableIF::VAR_WRITE and
+            registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) {
+        if(protectEveryReadCommitCall) {
+            result = registeredVariables[count]->read(timeoutTypeForSingleVars,
+                    mutexTimeoutForSingleVars);
+        }
+        else {
+            /* The readWithoutLock function is protected, so we use the attorney here */
+            result = ReadCommitIFAttorney::readWithoutLock(registeredVariables[count]);
+        }
+
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            result = INVALID_PARAMETER_DEFINITION;
+        }
+    }
+    return result;
+}
+
+ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
+        uint32_t lockTimeout) {
+    if (state == States::STATE_SET_WAS_READ) {
+        handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return handleUnreadDatasetCommit(timeoutType, lockTimeout);
+    }
+}
+
+void PoolDataSetBase::handleAlreadyReadDatasetCommit(
+        MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
+    lockDataPool(timeoutType, lockTimeout);
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if ((registeredVariables[count]->getReadWriteMode() != PoolVariableIF::VAR_READ) and
+                (registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER)) {
+            if(protectEveryReadCommitCall) {
+                registeredVariables[count]->commit(timeoutTypeForSingleVars,
+                        mutexTimeoutForSingleVars);
+            }
+            else {
+                /* The commitWithoutLock function is protected, so we use the attorney here */
+                ReadCommitIFAttorney::commitWithoutLock(registeredVariables[count]);
+            }
+        }
+    }
+    state = States::STATE_SET_UNINITIALISED;
+    unlockDataPool();
+}
+
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
+        MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    lockDataPool(timeoutType, lockTimeout);
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if ((registeredVariables[count]->getReadWriteMode() == PoolVariableIF::VAR_WRITE) and
+                (registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER)) {
+            if(protectEveryReadCommitCall) {
+                result = registeredVariables[count]->commit(timeoutTypeForSingleVars,
+                        mutexTimeoutForSingleVars);
+            }
+            else {
+                /* The commitWithoutLock function is protected, so we use the attorney here */
+                ReadCommitIFAttorney::commitWithoutLock(registeredVariables[count]);
+            }
+
+        } else if (registeredVariables[count]->getDataPoolId()
+                != PoolVariableIF::NO_PARAMETER) {
+            if (result != COMMITING_WITHOUT_READING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+                sif::error << "DataSet::commit(): commit-without-read call made "
+                        "with non write-only variable." << std::endl;
+#endif
+                result = COMMITING_WITHOUT_READING;
+            }
+        }
+    }
+    state = States::STATE_SET_UNINITIALISED;
+    unlockDataPool();
+    return result;
+}
+
+
+ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
+        uint32_t lockTimeout) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PoolDataSetBase::unlockDataPool() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size,
+        const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->serialize(buffer, size, maxSize, streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    return result;
+}
+
+ReturnValue_t PoolDataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->deSerialize(buffer, size,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    return result;
+}
+
+size_t PoolDataSetBase::getSerializedSize() const {
+    uint32_t size = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        size += registeredVariables[count]->getSerializedSize();
+    }
+    return size;
+}
+
+void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
+    this->registeredVariables = variablesContainer;
+}
+
+PoolVariableIF** PoolDataSetBase::getContainer() const {
+    return registeredVariables;
+}
+
+void PoolDataSetBase::setReadCommitProtectionBehaviour(
+        bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
+        uint32_t mutexTimeout) {
+    this->protectEveryReadCommitCall = protectEveryReadCommit;
+    this->timeoutTypeForSingleVars = timeoutType;
+    this->mutexTimeoutForSingleVars = mutexTimeout;
+}

datapool/PoolDataSetBase.h

@@ -0,0 +1,180 @@
+#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
+#define FSFW_DATAPOOL_POOLDATASETBASE_H_
+
+#include "PoolDataSetIF.h"
+#include "PoolVariableIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MutexIF.h"
+
+/**
+ * @brief	The DataSetBase class manages a set of locally checked out variables.
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the data pool,
+ * to ensure that all values are read and written back at once.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * The base class lockDataPool und unlockDataPool implementation are empty
+ * and should be implemented to protect the underlying pool type.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class PoolDataSetBase:
+        public PoolDataSetIF,
+        public SerializeIF,
+        public HasReturnvaluesIF {
+public:
+
+    /**
+     * @brief	Creates an empty dataset. Use registerVariable or
+     * 			supply a pointer to this dataset to PoolVariable
+     * 			initializations to register pool variables.
+     */
+    PoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxFillCount);
+
+    /* Forbidden for now */
+    PoolDataSetBase(const PoolDataSetBase& otherSet) = delete;
+    const PoolDataSetBase& operator=(const PoolDataSetBase& otherSet) = delete;
+
+    virtual~ PoolDataSetBase();
+
+    /**
+     * @brief	The read call initializes reading out all registered variables.
+     * 			It is mandatory to call commit after every read call!
+     * @details
+     * It iterates through the list of registered variables and calls all read()
+     * functions of the registered pool variables (which read out their values
+     * from the data pool) which are not write-only.
+     * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+     * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+     *
+     * The data pool is locked during the whole read operation and
+     * freed afterwards. It is mandatory to call commit after a read call,
+     * even if the read operation is not successful!
+     * @return
+     * - @c RETURN_OK if all variables were read successfully.
+     * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
+     *      is a type conflict.
+     * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
+     *      commit() in between
+     */
+    virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t lockTimeout = 20) override;
+    /**
+     * @brief	The commit call initializes writing back the registered variables.
+     * @details
+     * It iterates through the list of registered variables and calls the
+     * commit() method of the remaining registered variables (which write back
+     * their values to the pool).
+     *
+     * The data pool is locked during the whole commit operation and
+     * freed afterwards. The state changes to "was committed" after this operation.
+     *
+     * If the set does contain at least one variable which is not write-only
+     * commit() can only be called after read(). If the set only contains
+     * variables which are write only, commit() can be called without a
+     * preceding read() call. Every read call must be followed by a commit call!
+     * @return	- @c RETURN_OK if all variables were read successfully.
+     * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+     * 			  contains non write-only variables
+     */
+    virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t lockTimeout = 20) override;
+
+    /**
+     * Register the passed pool variable instance into the data set.
+     * @param variable
+     * @return
+     */
+    virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+
+    /**
+     * Provides the means to lock the underlying data structure to ensure
+     * thread-safety. Default implementation is empty
+     * @return Always returns -@c RETURN_OK
+     */
+    virtual ReturnValue_t lockDataPool(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+    /**
+     * Provides the means to unlock the underlying data structure to ensure
+     * thread-safety. Default implementation is empty
+     * @return Always returns -@c RETURN_OK
+     */
+    virtual ReturnValue_t unlockDataPool() override;
+
+    virtual uint16_t getFillCount() const;
+
+    /* SerializeIF implementations */
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            const size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const override;
+    virtual size_t getSerializedSize() const override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override;
+
+    /**
+     * Can be used to individually protect every read and commit call.
+     * @param protectEveryReadCommit
+     * @param mutexTimeout
+     */
+    void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t mutexTimeout = 20);
+protected:
+
+    /**
+     * @brief	The fill_count attribute ensures that the variables
+     * 			register in the correct array position and that the maximum
+     * 			number of variables is not exceeded.
+     */
+    uint16_t fillCount = 0;
+    /**
+     * States of the seet.
+     */
+    enum class States {
+        STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+        STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
+    };
+    /**
+     * @brief	state manages the internal state of the data set,
+     *          which is important e.g. for the behavior on destruction.
+     */
+    States state = States::STATE_SET_UNINITIALISED;
+
+    /**
+     * @brief	This array represents all pool variables registered in this set.
+     * Child classes can use a static or dynamic container to create
+     * an array of registered variables and assign the first entry here.
+     */
+    PoolVariableIF** registeredVariables = nullptr;
+    const size_t maxFillCount = 0;
+
+    void setContainer(PoolVariableIF** variablesContainer);
+    PoolVariableIF** getContainer() const;
+
+private:
+    bool protectEveryReadCommitCall = false;
+    MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeoutForSingleVars = 20;
+
+    ReturnValue_t readVariable(uint16_t count);
+    void handleAlreadyReadDatasetCommit(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+    ReturnValue_t handleUnreadDatasetCommit(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+};
+
+#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */

datapool/PoolDataSetIF.h

@@ -0,0 +1,36 @@
+#ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
+#define FSFW_DATAPOOL_POOLDATASETIF_H_
+
+#include "ReadCommitIF.h"
+#include "DataSetIF.h"
+
+/**
+ * @brief   Extendes the DataSetIF by adding abstract functions to lock
+ *          and unlock a data pool and read/commit semantics.
+ */
+class PoolDataSetIF:
+        virtual public DataSetIF,
+        virtual public ReadCommitIF {
+public:
+    virtual~ PoolDataSetIF() {};
+
+    /**
+     * @brief   Most underlying data structures will have a pool like structure
+     *          and will require a lock and unlock mechanism to ensure
+     *          thread-safety
+     * @return Lock operation result
+     */
+    virtual ReturnValue_t lockDataPool(
+    		MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) = 0;
+
+    /**
+     * @brief   Unlock call corresponding to the lock call.
+     * @return Unlock operation result
+     */
+    virtual ReturnValue_t unlockDataPool() = 0;
+
+    virtual bool isValid() const = 0;
+};
+
+#endif /* FSFW_DATAPOOL_POOLDATASETIF_H_ */

datapool/PoolEntry.cpp

@@ -1,28 +1,24 @@
-#include <framework/datapool/PoolEntry.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
+#include "PoolEntry.h"
+
+#include "../serviceinterface/ServiceInterface.h"
+#include "../globalfunctions/arrayprinter.h"
 #include <cstring>
+#include <algorithm>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), valid(setValid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid ):
+		length(static_cast<uint8_t>(initValue.size())), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		std::memset(this->address, 0, this->getByteSize());
 	}
-	else if (initValue.size() != setLength){
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-		std::memset(this->address, 0, this->getByteSize());
-	}
 	else {
 		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid):
 		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if (initValue != nullptr) {
@@ -66,10 +62,26 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-	sif::debug << std::dec << std::endl;
+	const char* validString = nullptr;
+	if(valid) {
+		validString = "Valid";
+	}
+	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
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
+}
+
+template<typename T>
+inline T* PoolEntry<T>::getDataPtr() {
+	return this->address;
 }
 
 template<typename T>
@@ -80,8 +92,10 @@ Type PoolEntry<T>::getType() {
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;
+template class PoolEntry<uint64_t>;
 template class PoolEntry<int8_t>;
 template class PoolEntry<int16_t>;
 template class PoolEntry<int32_t>;
+template class PoolEntry<int64_t>;
 template class PoolEntry<float>;
 template class PoolEntry<double>;

datapool/PoolEntry.h

@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#ifndef FSFW_DATAPOOL_POOLENTRY_H_
+#define FSFW_DATAPOOL_POOLENTRY_H_
 
-#include <framework/datapool/PoolEntryIF.h>
+#include "PoolEntryIF.h"
 
 #include <initializer_list>
 #include <type_traits>
@@ -35,24 +35,22 @@ public:
 				"uint8_t");
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
+	 * 			potential initialization values are copied to that space.
 	 * @details
 	 * Not passing any arguments will initialize an non-array pool entry
-	 * (setLength = 1) with an initial invalid state.
-	 * Please note that if an initializer list is passed, the correct
-	 * corresponding length should be passed too, otherwise a zero
-	 * initialization will be performed with the given setLength.
+	 * with an initial invalid state and the value 0.
+	 * Please note that if an initializer list is passed, the length of the
+	 * initializer list needs to be correct for vector entries because
+	 * required allocated space will be deduced from the initializer list length
+	 * and the pool entry type.
 	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
+	 * Initializer list with values to initialize with, for example {0, 0} to
+	 * initialize the a pool entry of a vector with two entries to 0.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
+	PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);
+
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
@@ -66,9 +64,9 @@ public:
 	 */
 	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
 
-	//! Explicitely deleted copy ctor, copying is not allowed!
+	//! Explicitely deleted copy ctor, copying is not allowed.
 	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
+	//! Explicitely deleted copy assignment, copying is not allowed.
 	PoolEntry& operator=(const PoolEntry&) = delete;
 
 	/**
@@ -82,21 +80,16 @@ public:
 	~PoolEntry();
 
 	/**
-	 * @brief	This is the address pointing to the allocated memory.
+	 * Return typed pointer to start of data.
+	 * @return
 	 */
-	T* address;
-	/**
-	 * @brief	This attribute stores the length information.
-	 */
-	uint8_t length;
-	/**
-	 * @brief	Here, the validity information for a variable is stored.
-	 * 			Every entry (single variable or vector) has one valid flag.
-	 */
-	uint8_t valid;
+	T* getDataPtr();
+
 	/**
 	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
+	 * @details
+	 * For non-array pool entries return type size, for vector entries
+	 * return type size times the number of entries.
 	 */
 	uint8_t getSize();
 	/**
@@ -123,8 +116,22 @@ public:
 	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	void print();
-
 	Type getType();
+
+private:
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
 };
 
-#endif /* POOLENTRY_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRY_H_ */

datapool/PoolEntryIF.h

@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#ifndef FSFW_DATAPOOL_POOLENTRYIF_H_
+#define FSFW_DATAPOOL_POOLENTRYIF_H_
 
-#include <framework/globalfunctions/Type.h>
+#include "../globalfunctions/Type.h"
 #include <cstdint>
 
 /**
@@ -60,4 +60,4 @@ public:
 	virtual Type getType() = 0;
 };
 
-#endif /* POOLENTRYIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRYIF_H_ */

datapool/PoolRawAccessHelper.cpp

@@ -1,188 +0,0 @@
-/**
- * @file PoolRawAccessHelper.cpp
- *
- * @date 22.12.2019
- * @author R. Mueller
- */
-
-#include <framework/datapool/PoolRawAccessHelper.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <cmath>
-#include <cstring>
-
-PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
-		uint8_t  numberOfParameters_):
-		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
-		numberOfParameters(numberOfParameters_), validBufferIndex(0),
-		validBufferIndexBit(1) {
-}
-
-PoolRawAccessHelper::~PoolRawAccessHelper() {
-}
-
-ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) {
-	SerializationArgs serializationArgs = {buffer, size, max_size,
-	        streamEndianness};
-	ReturnValue_t result = RETURN_OK;
-	size_t remainingParametersSize = numberOfParameters * 4;
-	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
-				&remainingParametersSize, false);
-		if(result != RETURN_OK) {
-			return result;
-		}
-	}
-	if(remainingParametersSize != 0) {
-		sif::debug << "PoolRawAccessHelper: "
-				"Remaining parameters size not 0 !" << std::endl;
-		result = RETURN_FAILED;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
-		size_t * size, const size_t max_size,
-		SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_OK;
-	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
-	size_t remainingParametersSize = numberOfParameters * 4;
-	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
-	uint8_t validityMask[validityMaskSize];
-	memset(validityMask,0, validityMaskSize);
-	for(uint8_t count = 0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(argStruct,
-				&remainingParametersSize,true,validityMask);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	if(remainingParametersSize != 0) {
-		sif::debug << "PoolRawAccessHelper: Remaining "
-				"parameters size not 0 !" << std::endl;
-		result = RETURN_FAILED;
-	}
-
-	memcpy(*argStruct.buffer, validityMask, validityMaskSize);
-	*size += validityMaskSize;
-	validBufferIndex = 1;
-	validBufferIndexBit = 0;
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
-		SerializationArgs argStruct, size_t * remainingParameters,
-		bool withValidMask, uint8_t * validityMask) {
-	uint32_t currentPoolId;
-	// Deserialize current pool ID from pool ID buffer
-	ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
-	if(result != RETURN_OK) {
-		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
-				"pool IDs" << std::dec << std::endl;
-		return result;
-	}
-	result = handlePoolEntrySerialization(currentPoolId, argStruct,
-			withValidMask, validityMask);
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
-		uint32_t currentPoolId,SerializationArgs argStruct, bool withValidMask,
-		uint8_t * validityMask) {
-	ReturnValue_t result = RETURN_FAILED;
-	uint8_t arrayPosition = 0;
-	uint8_t counter = 0;
-	bool poolEntrySerialized = false;
-	//debug << "Pool Raw Access Helper: Handling Pool ID: "
-	//      << std::hex <<  currentPoolId << std::endl;
-	while(not poolEntrySerialized) {
-
-		if(counter > GlobDataSet::DATA_SET_MAX_SIZE) {
-			sif::error << "PoolRawAccessHelper: Config error, "
-					 "max. number of possible data set variables exceeded"
-				  << std::endl;
-			return result;
-		}
-		counter ++;
-
-		GlobDataSet currentDataSet;
-		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
-				&currentDataSet, PoolVariableIF::VAR_READ);
-
-		result = currentDataSet.read();
-		if (result != RETURN_OK) {
-			sif::debug << std::hex << "PoolRawAccessHelper: Error reading raw "
-					"dataset with returncode 0x" << result << std::dec << std::endl;
-			return result;
-		}
-
-		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
-				&arrayPosition);
-		if(result != RETURN_OK) {
-			sif::error << "Pool Raw Access Helper: Configuration Error at pool ID "
-				  << std::hex << currentPoolId
-				  << ". Size till end smaller than 0" << std::dec << std::endl;
-			return result;
-		}
-
-		// set valid mask bit if necessary
-		if(withValidMask) {
-			if(currentPoolRawAccess.isValid()) {
-				handleMaskModification(validityMask);
-			}
-			validBufferIndexBit ++;
-		}
-
-		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
-				argStruct.max_size, argStruct.streamEndianness);
-		if (result != RETURN_OK) {
-			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
-					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
-					 "with return code " << result << std::dec << std::endl;
-			return result;
-		}
-
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
-		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
-	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
-			currentPoolRawAccess->getSizeOfType();
-	if(remainingSize == 0) {
-		*isSerialized = true;
-	}
-	else if(remainingSize > 0) {
-		*arrayPosition += 1;
-	}
-	else {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
-	validityMask[validBufferIndex] =
-			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-	if(validBufferIndexBit == 8) {
-		validBufferIndex ++;
-		validBufferIndexBit = 1;
-	}
-}
-
-uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
-		bool value) {
-	if(position < 1 or position > 8) {
-		sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-		return byte;
-	}
-	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
-	byte |= 1UL << shiftNumber;
-	return byte;
-}

datapool/PoolRawAccessHelper.h

@@ -1,111 +0,0 @@
-/**
- * @file PoolRawAccessHelper.h
- *
- * @date 22.12.2019
- */
-
-#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-
-/**
- * @brief 	This helper function simplifies accessing data pool entries
- *  	  	via PoolRawAccess
- * @details Can be used for a Housekeeping Service
- * 			like  ECSS PUS Service 3 if the type of the datapool entries is unknown.
- * 			The provided dataset can be serialized into a provided buffer automatically by
- * 			providing a buffer of pool IDs
- * @ingroup data_pool
- */
-class PoolRawAccessHelper: public HasReturnvaluesIF {
-public:
-	/**
-	 * Call this constructor if a dataset needs to be serialized via
-	 * Pool Raw Access
-	 * @param dataSet_ This dataset will be used to perform thread-safe reading
-	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
-	 * @param numberOfParameters_ The number of parameters / pool IDs
-	 */
-	PoolRawAccessHelper(uint32_t * poolIdBuffer_, uint8_t numberOfParameters_);
-	virtual ~PoolRawAccessHelper();
-
-	/**
-	 * Serialize the datapool entries derived from the pool ID buffer
-	 * directly into a provided buffer
-	 * @param [out] buffer
-	 * @param [out] size Size of the serialized buffer
-	 * @param max_size
-	 * @param bigEndian
-	 * @return 	@c RETURN_OK On success
-	 * 			@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
-			const size_t max_size, SerializeIF::Endianness streamEndianness);
-
-	/**
-	 * Serializes data pool entries into provided buffer with the validity mask buffer
-	 * at the end of the buffer. Every bit of the validity mask denotes
-	 * the validity of a corresponding data pool entry from left to right.
-	 * @param [out] buffer
-	 * @param [out] size Size of the serialized buffer plus size
-	 *                   of the validity mask
-	 * @return 	@c RETURN_OK On success
-	 * 			@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
-			const size_t max_size, SerializeIF::Endianness streamEndianness);
-
-
-private:
-	// DataSet * dataSet;
-	const uint8_t * poolIdBuffer;
-	uint8_t numberOfParameters;
-
-	uint8_t validBufferIndex;
-	uint8_t validBufferIndexBit;
-
-	struct SerializationArgs {
-		uint8_t ** buffer;
-		size_t * size;
-		const size_t max_size;
-		SerializeIF::Endianness streamEndianness;
-	};
-	/**
-	 * Helper function to serialize single pool entries
-	 * @param pPoolIdBuffer
-	 * @param buffer
-	 * @param remainingParameters
-	 * @param hkDataSize
-	 * @param max_size
-	 * @param bigEndian
-	 * @param withValidMask Can be set optionally to set a
-	 *        provided validity mask
-	 * @param validityMask Can be supplied and will be set if
-	 *  	  @c withValidMask is set to true
-	 * @return
-	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(
-			SerializationArgs argStruct, size_t * remainingParameters,
-			bool withValidMask = false, uint8_t * validityMask = nullptr);
-
-	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
-			SerializationArgs argStruct, bool withValidMask = false,
-			uint8_t * validityMask = nullptr);
-
-	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
-			bool * isSerialized, uint8_t * arrayPosition);
-	void handleMaskModification(uint8_t * validityMask);
-	/**
-	 * Sets specific bit of a byte
-	 * @param byte
-	 * @param position Position of byte to set from 1 to 8
-	 * @param value Binary value to set
-	 * @return
-	 */
-	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
-};
-
-#endif /* FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_ */

datapool/PoolReadGuard.h

@@ -0,0 +1,62 @@
+#ifndef FSFW_DATAPOOL_POOLREADHELPER_H_
+#define FSFW_DATAPOOL_POOLREADHELPER_H_
+
+#include "ReadCommitIF.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include <FSFWConfig.h>
+
+/**
+ * @brief 	Helper class to read data sets or pool variables
+ */
+class PoolReadGuard {
+public:
+    PoolReadGuard(ReadCommitIF* readObject,
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t mutexTimeout = 20):
+                readObject(readObject), mutexTimeout(mutexTimeout) {
+        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 */
+            }
+        }
+    }
+
+    ReturnValue_t getReadResult() const {
+        return readResult;
+    }
+
+    /**
+     * @brief   Can be used to suppress commit on destruction.
+     */
+    void setNoCommitMode(bool commit) {
+        this->noCommit = commit;
+    }
+
+    /**
+     * @brief   Default destructor which will take care of commiting changed values.
+     */
+    ~PoolReadGuard() {
+        if(readObject != nullptr and not noCommit) {
+            readObject->commit(timeoutType, mutexTimeout);
+        }
+
+    }
+
+private:
+    ReadCommitIF* readObject = nullptr;
+    ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+    bool noCommit = false;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeout = 20;
+};
+
+
+
+#endif /* FSFW_DATAPOOL_POOLREADHELPER_H_ */

datapool/PoolVarList.h

@@ -1,14 +1,15 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
+#ifndef FSFW_DATAPOOL_POOLVARLIST_H_
+#define FSFW_DATAPOOL_POOLVARLIST_H_
 
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 template <class T, uint8_t n_var>
 class PoolVarList {
 private:
 	GlobPoolVar<T> variables[n_var];
 public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet,
+	        PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
 		//I really should have a look at the new init list c++ syntax.
 		if (dataSet == NULL) {
 			return;
@@ -25,4 +26,4 @@ public:
 
 
 
-#endif /* POOLVARLIST_H_ */
+#endif /* FSFW_DATAPOOL_POOLVARLIST_H_ */

datapool/PoolVariableIF.h

@@ -1,8 +1,10 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
+#define FSFW_DATAPOOL_POOLVARIABLEIF_H_
+
+#include "ReadCommitIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
 
 /**
  * @brief	This interface is used to control data pool
@@ -17,83 +19,50 @@
  * @author 	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolVariableIF : public SerializeIF {
-	friend class DataSetBase;
-	friend class GlobDataSet;
-	friend class LocalDataSet;
+class PoolVariableIF :
+        public SerializeIF,
+        public ReadCommitIF {
+
 public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
-	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
+    static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+    static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
-	static constexpr bool VALID = 1;
-	static constexpr bool INVALID = 0;
-	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
+    static constexpr bool VALID = 1;
+    static constexpr bool INVALID = 0;
+    static constexpr uint32_t NO_PARAMETER = 0xffffffff;
 
-	enum ReadWriteMode_t {
-		VAR_READ, VAR_WRITE, VAR_READ_WRITE
-	};
+    enum ReadWriteMode_t {
+        VAR_READ, VAR_WRITE, VAR_READ_WRITE
+    };
 
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
-	 */
-	virtual ~PoolVariableIF() {}
-	/**
-	 * @brief	This method returns if the variable is write-only,
-	 * 			read-write or read-only.
-	 */
-	virtual ReadWriteMode_t getReadWriteMode() const = 0;
-	/**
-	 * @brief	This operation shall return the data pool id of the variable.
-	 */
-	virtual uint32_t getDataPoolId() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the
-	 * 			variable is returned.
-	 */
-	virtual bool isValid() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the variable is set.
-	 */
-	virtual void setValid(bool validity) = 0;
+    /**
+     * @brief	This is an empty virtual destructor,
+     * 			as it is proposed for C++ interfaces.
+     */
+    virtual ~PoolVariableIF() {}
+    /**
+     * @brief	This method returns if the variable is write-only,
+     * 			read-write or read-only.
+     */
+    virtual ReadWriteMode_t getReadWriteMode() const = 0;
+    virtual void setReadWriteMode(ReadWriteMode_t newMode) = 0;
 
-	/**
-	 * @brief	The commit call shall write back a newly calculated local
-	 * 			value to the data pool.
-	 * @details
-	 * It is assumed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
-	/**
-	 * @brief	The read call shall read the value of this parameter from
-	 * 			the data pool and store the content locally.
-	 * @details
-	 * It is assumbed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-
-protected:
-
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t readWithoutLock() = 0;
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t commitWithoutLock() = 0;
+    /**
+     * @brief	This operation shall return the data pool id of the variable.
+     */
+    virtual uint32_t getDataPoolId() const = 0;
+    /**
+     * @brief	With this call, the valid information of the
+     * 			variable is returned.
+     */
+    virtual bool isValid() const = 0;
+    /**
+     * @brief	With this call, the valid information of the variable is set.
+     */
+    virtual void setValid(bool validity) = 0;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
 
-#endif /* POOLVARIABLEIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLVARIABLEIF_H_ */

datapool/ReadCommitIF.h

@@ -0,0 +1,34 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIF_H_
+#define FSFW_DATAPOOL_READCOMMITIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexIF.h"
+
+/**
+ * @brief 	Common interface for all software objects which employ read-commit
+ * 			semantics.
+ */
+class ReadCommitIF {
+    friend class ReadCommitIFAttorney;
+public:
+	virtual ~ReadCommitIF() {}
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+
+protected:
+
+	/* Optional and protected because this is interesting for classes grouping members with commit
+	and read semantics where the lock is only necessary once. */
+	virtual ReturnValue_t readWithoutLock()  {
+		return read(MutexIF::TimeoutType::WAITING, 20);
+	}
+
+	virtual ReturnValue_t commitWithoutLock() {
+		return commit(MutexIF::TimeoutType::WAITING, 20);
+	}
+};
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */

datapool/ReadCommitIFAttorney.h

@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
+#define FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
+
+#include <fsfw/datapool/ReadCommitIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief   This class determines which members are allowed to access protected members
+ *          of the ReadCommitIF.
+ */
+class ReadCommitIFAttorney {
+private:
+    static ReturnValue_t readWithoutLock(ReadCommitIF* readCommitIF) {
+        if(readCommitIF == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return readCommitIF->readWithoutLock();
+    }
+
+    static ReturnValue_t commitWithoutLock(ReadCommitIF* readCommitIF) {
+        if(readCommitIF == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return readCommitIF->commitWithoutLock();
+    }
+
+    friend class PoolDataSetBase;
+};
+
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_ */

datapool/SharedDataSetIF.h

@@ -0,0 +1,16 @@
+#ifndef FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+
+#include "PoolDataSetIF.h"
+
+class SharedDataSetIF {
+public:
+    virtual ~SharedDataSetIF() {};
+
+private:
+    virtual ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType,
+            dur_millis_t mutexTimeout) = 0;
+    virtual ReturnValue_t unlockDataset() = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_ */

datapoolglob/DataPoolAdmin.cpp

@@ -1,300 +0,0 @@
-#include <framework/datapoolglob/DataPoolAdmin.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/parameters/ParameterMessage.h>
-
-DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
-		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
-				this, NULL), actionHelper(this, NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-DataPoolAdmin::~DataPoolAdmin() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
-	handleCommand();
-	return RETURN_OK;
-}
-
-MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	if (actionId != SET_VALIDITY) {
-		return INVALID_ACTION_ID;
-	}
-
-	if (size != 5) {
-		return INVALID_PARAMETERS;
-	}
-
-	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
-			| data[3];
-
-	uint8_t valid = data[4];
-
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-
-	GlobDataSet mySet;
-	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
-	ReturnValue_t status = mySet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	if (valid != 0) {
-		variable.setValid(PoolVariableIF::VALID);
-	} else {
-		variable.setValid(PoolVariableIF::INVALID);
-	}
-
-	mySet.commit();
-
-	return EXECUTION_FINISHED;
-}
-
-ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = handleParameterCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = memoryHelper.handleMemoryCommand(&command);
-	if (result != RETURN_OK) {
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, size_t size, uint8_t** dataPointer) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-
-	if (size % typeSize != 0) {
-		return INVALID_SIZE;
-	}
-
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	const uint8_t* readPosition = data;
-
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ_WRITE);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			status = variable.setEntryFromBigEndian(readPosition, typeSize);
-			if (status == RETURN_OK) {
-				status = rawSet.commit();
-			}
-		}
-		arrayIndex += 1;
-		readPosition += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
-		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	uint8_t* ptrToCopy = copyHere;
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			size_t temp = 0;
-			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
-			if (status != RETURN_OK) {
-				return RETURN_FAILED;
-			}
-		} else {
-			//Error reading parameter.
-		}
-		arrayIndex += 1;
-		ptrToCopy += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = memoryHelper.initialize(commandQueue);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	result = actionHelper.initialize(commandQueue);
-
-	return result;
-}
-
-//mostly identical to ParameterHelper::handleParameterMessage()
-ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (command->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-
-		DataPoolParameterWrapper wrapper;
-		result = wrapper.set(domain, parameterId);
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &wrapper);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(command));
-
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
-		result = storage->getData(ParameterMessage::getStoreId(command),
-				&storedStream, &storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		DataPoolParameterWrapper poolWrapper;
-		result = poolWrapper.set(domain, parameterId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		result = poolWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(command));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &poolWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(command->getSender(), result, command->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-//identical to ParameterHelper::sendParameter()
-ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
-		const DataPoolParameterWrapper* wrapper) {
-	size_t serializedSize = wrapper->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	commandQueue->sendMessage(to, &reply);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//identical to ParameterHelper::rejectCommand()
-void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	commandQueue->sendMessage(to, &reply);
-}